Doodle3D-Slicer/library/cal.js
2015-04-24 21:32:39 +02:00

2330 lines
63 KiB
JavaScript

//canvas cheat sheet
//http://cheatsheetworld.com/programming/html5-canvas-cheat-sheet/
//TODO
//Global Composite Operation
//Linear Gradient
//Radial Gradient
//Bezier Curve
//Circle
//Touch support
"use strict";
var CAL = {
name: "Canvas Abstraction Layer",
version: "1.0",
author: "Casper Lamboo",
contact: "casperlamboo@gmail.com"
};
CAL.Math = {
clamb: function (value, min, max) {
return (value > min) ? ((value < max) ? value : max) : min;
},
randomInt: function (min, max) {
return Math.round(CAL.Math.random(min, max));
},
random: function (min, max) {
min = min || 0;
max = max === undefined ? 1 : max;
return Math.random()*(max - min) + min;
},
sign: function (value) {
return (value > 0) ? 1 : ((value < 0) ? -1 : 0);
},
lineCollision: function (v1, v2, v3, v4) {
//bron: http://mathworld.wolfram.com/Line-LineIntersection.html
var intersection = new CAL.Vector(
((v1.x*v2.y-v1.y*v2.x)*(v3.x-v4.x)-(v1.x-v2.x)*(v3.x*v4.y-v3.y*v4.x)) / ((v1.x-v2.x)*(v3.y-v4.y)-(v1.y-v2.y)*(v3.x-v4.x)),
((v1.x*v2.y-v1.y*v2.x)*(v3.y-v4.y)-(v1.y-v2.y)*(v3.x*v4.y-v3.y*v4.x)) / ((v1.x-v2.x)*(v3.y-v4.y)-(v1.y-v2.y)*(v3.x-v4.x))
);
var line1 = v1.subtract(v2).length();
var line2 = v3.subtract(v4).length();
var a = line1 >= v1.subtract(intersection).length();
var b = line1 >= v2.subtract(intersection).length();
var c = line2 >= v3.subtract(intersection).length();
var d = line2 >= v4.subtract(intersection).length();
return (a && b && c && d) ? intersection : false;
}
};
CAL.Easings = {
bounceEaseOut: function (dt, b, c, d) {
if ((dt /= d) < (1 / 2.75)) {
return c * (7.5625 * dt * dt) + b;
}
else if (dt < (2 / 2.75)) {
return c * (7.5625 * (dt -= (1.5 / 2.75)) * dt + 0.75) + b;
}
else if (dt < (2.5 / 2.75)) {
return c * (7.5625 * (dt -= (2.25 / 2.75)) * dt + 0.9375) + b;
}
else {
return c * (7.5625 * (dt -= (2.625 / 2.75)) * dt + 0.984375) + b;
}
},
easeIn: function (dt, b, c, d) {
return c * (dt /= d) * dt + b;
},
easeOut: function (dt, b, c, d) {
return -c * (dt /= d) * (dt - 2) + b;
},
easeInOut: function (dt, b, c, d) {
if ((dt /= d / 2) < 1) {
return c / 2 * dt * dt + b;
}
return -c / 2 * ((--dt) * (dt - 2) - 1) + b;
},
strongEaseIn: function (dt, b, c, d) {
return c * (dt /= d) * dt * dt * dt * dt + b;
},
strongEaseOut: function (dt, b, c, d) {
return c * (( dt = dt / d - 1) * dt * dt * dt * dt + 1) + b;
},
strongEaseInOut: function (dt, b, c, d) {
if ((dt /= d / 2) < 1) {
return c / 2 * dt * dt * dt * dt * dt + b;
}
return c / 2 * ((dt -= 2) * dt * dt * dt * dt + 2) + b;
},
linear: function (dt, b, c, d) {
return c * dt / d + b;
}
};
//this doesn't work, everything is an instance of Object in JavaScript
/*Object.prototype.clone = function () {
var object = {};
for (var i in this) {
var element = this[i];
object[i] = element.clone ? element.clone() : element;
}
return object;
};
Object.prototype.foreach = function (callback) {
for (var i in this) {
var element = this[i];
callback(element, i);
}
};*/
Array.prototype.foreach = function (callback, scope) {
for (var i = 0; i < this.length; i ++) {
var element = this[i];
if ((scope !== undefined) ? callback.call(scope, element, i) : callback(element, i)) {
break;
}
}
};
Array.prototype.foreachReverse = function (callback, scope) {
for (var i = this.length-1; i >= 0; i --) {
var element = this[i];
if ((scope !== undefined) ? callback.call(scope, element, i) : callback(element, i)) {
break;
}
}
};
Array.prototype.max = function () {
var max = -Infinity;
this.foreach(function (element) {
if (element > max) {
max = element;
}
});
return max;
};
Array.prototype.min = function () {
var min = Infinity;
this.foreach(function (element) {
if (element < min) {
min = element;
}
});
return min;
};
Array.prototype.clone = function () {
var array = [];
this.foreach(function (element) {
array.push((element.clone !== undefined) ? element.clone() : element);
});
return array;
};
Array.prototype.remove = function () {
for (var i = 0; i < arguments.length; i ++) {
var element = arguments[i];
var index = this.indexOf(element);
if (index !== -1) {
this.splice(index, 1);
}
}
};
var requestAnimFrame = (function () {
return requestAnimationFrame || webkitRequestAnimationFrame || mozRequestAnimationFrame || function (callback) {
setTimeout(callback, 1000/60);
};
})();
CAL.Vector = function (x, y) {
this.x = x || 0;
this.y = y || 0;
};
CAL.Vector.prototype.add = function (vector) {
var x = this.x + vector.x;
var y = this.y + vector.y;
return new CAL.Vector(x, y);
};
CAL.Vector.prototype.subtract = function (vector) {
var x = this.x - vector.x;
var y = this.y - vector.y;
return new CAL.Vector(x, y);
};
CAL.Vector.prototype.scale = function (scalar) {
var x = this.x * scalar;
var y = this.y * scalar;
return new CAL.Vector(x, y);
};
CAL.Vector.prototype.rotate = function (angle) {
var cos = Math.cos(angle);
var sin = Math.sin(angle);
var x = cos*this.x - sin*this.y;
var y = sin*this.x + cos*this.y;
return new CAL.Vector(x, y);
};
CAL.Vector.prototype.multiply = function (vector) {
var x = this.x * vector.x;
var y = this.y * vector.y;
return new CAL.Vector(x, y);
};
CAL.Vector.prototype.length = function () {
return Math.sqrt(this.x*this.x + this.y*this.y);
};
CAL.Vector.prototype.normal = function () {
return new CAL.Vector(this.y, -this.x);
};
CAL.Vector.prototype.normalize = function () {
var length = this.length();
var x = this.x/length;
var y = this.y/length;
return new CAL.Vector(x, y);
};
CAL.Vector.prototype.angle = function () {
return Math.atan2(this.y, this.x);
};
CAL.Vector.prototype.dot = function (vector) {
return this.x * vector.x + this.y * vector.y;
};
CAL.Vector.prototype.cross = function (vector) {
return this.x * vector.y - this.y * vector.x;
};
CAL.Vector.prototype.round = function () {
var x = Math.round(this.x);
var y = Math.round(this.y);
return new CAL.Vector(x, y);
};
CAL.Vector.prototype.applyMatrix = function (matrix) {
var m = matrix.matrix;
var x = m[0]*this.x + m[1]*this.y + m[2];
var y = m[3]*this.x + m[4]*this.y + m[5];
return new CAL.Vector(x, y);
};
CAL.Vector.prototype.clone = function () {
return new CAL.Vector(this.x, this.y);
};
CAL.Vector.prototype.draw = function (context, x, y) {
var end = new CAL.Vector(this.x + x, this.y + y);
var arrowOrigin = new CAL.Vector(x, y).add(this.subtract(this.normalize().scale(10)));
var left = this.normal().normalize().scale(10).add(arrowOrigin);
var right = this.normal().normalize().scale(-10).add(arrowOrigin);
context.beginPath();
context.moveTo(x, y);
context.lineTo(end.x, end.y);
context.moveTo(left.x, left.y);
context.lineTo(end.x, end.y);
context.lineTo(right.x, right.y);
context.stroke();
};
CAL.Matrix = function (options) {
options = options || {};
if (options.matrix !== undefined && options.sx !== undefined && options.sy !== undefined && options.rotation !== undefined && options.x !== undefined && options.y !== undefined) {
this.matrix = options.matrix;
this._sx = options.sx;
this._sy = options.sy;
this._rotation = options.rotation;
this._x = options.x;
this._y = options.y;
}
else if (options instanceof Array || options.matrix) {
this.matrix = options.matrix || options;
this._sx = CAL.Math.sign(this.matrix[0])*Math.sqrt(Math.pow(this.matrix[0], 2) + Math.pow(this.matrix[1], 2));
this._sy = CAL.Math.sign(this.matrix[4])*Math.sqrt(Math.pow(this.matrix[3], 2) + Math.pow(this.matrix[4], 2));
this._rotation = Math.atan2(-this.matrix[1], this.matrix[0]);
this._x = this.matrix[2];
this._y = this.matrix[5];
//source: http://math.stackexchange.com/questions/13150/extracting-rotation-scale-values-from-2d-transformation-matrix
//BUG doesn't convert right when both sx and sy aren't 1
}
else {
this._sx = options.sx !== undefined ? options.sx : 1;
this._sy = options.sy !== undefined ? options.sy : 1;
this._x = options.x || 0;
this._y = options.y || 0;
if (options.rotation === undefined) {
this._rotation = 0;
this.matrix = [
this._sx, 0, this._x,
0, this._sy, this._y
];
}
else {
this._rotation = options.rotation;
this.updateMatrix();
}
}
};
CAL.Matrix.prototype = {
get sx () {
return this._sx;
},
set sx (sx) {
this._sx = sx;
this.updateMatrix();
},
get sy () {
return this._sy;
},
set sy (sy) {
this._sy = sy;
this.updateMatrix();
},
get rotation () {
return this._rotation;
},
set rotation (rotation) {
this._rotation = rotation;
this.updateMatrix();
},
get x () {
return this._x;
},
set x (x) {
this._x = this.matrix[2] = x;
},
get y () {
return this._y;
},
set y (y) {
this._y = this.matrix[5] = y;
}
};
CAL.Matrix.prototype.updateMatrix = function () {
this.matrix = [
this._sx * Math.cos(this._rotation), this._sy * -Math.sin(this._rotation), this._x,
this._sx * Math.sin(this._rotation), this._sy * Math.cos(this._rotation), this._y
];
};
CAL.Matrix.prototype.multiplyMatrix = function (matrix) {
var a = this.matrix;
var b = matrix.matrix;
var translation = new CAL.Vector(b[2], b[5]).applyMatrix(this);
return new CAL.Matrix([
a[0]*b[0] + a[3]*b[1], a[1]*b[0] + a[4]*b[1], translation.x,
a[0]*b[3] + a[3]*b[4], a[1]*b[3] + a[4]*b[4], translation.y,
]);
};
CAL.Matrix.prototype.inverse = function () {
var m = this.matrix;
return new CAL.Matrix([
m[4], -m[1], -m[2],
-m[3], m[0], -m[5]
]);
};
CAL.Matrix.prototype.translate = function (x, y) {
this.x += x;
this.y += y;
this.matrix[2] = this.x;
this.matrix[5] = this.y;
return this;
};
CAL.Matrix.prototype.setMatrix = function (matrix) {
this.matrix = matrix.matrix.clone();
this._x = matrix._x;
this._y = matrix._y;
this._sx = matrix._sx;
this._sy = matrix._sy;
this._rotation = matrix._rotation;
};
CAL.Matrix.prototype.setContext = function (context) {
var m = this.matrix;
context.transform(m[0], m[3], m[1], m[4], m[2], m[5]);
};
CAL.Matrix.prototype.rotateAroundAbsolute = function (angle, center) {
if (angle !== 0) {
var center = center
.subtract(new CAL.Vector(this.x, this.y))
.rotate(-this.rotation)
.multiply(new CAL.Vector(1/this.sx, 1/this.sy));
this.rotateAroundRelative(angle, center);
}
};
CAL.Matrix.prototype.rotateAroundRelative = function (angle, center) {
if (angle !== 0) {
var before = center.applyMatrix(this);
this.rotation += angle;
var after = center.applyMatrix(this);
var offset = before.subtract(after);
this._x += offset.x;
this._y += offset.y;
this.updateMatrix();
}
};
CAL.Matrix.prototype.clone = function () {
return new CAL.Matrix({
matrix: this.matrix.clone(),
sx: this._sx,
sy: this._sy,
rotation: this._rotation,
x: this._x,
y: this._y
});
};
CAL.Draw = function (centerX, centerY, numberWidth, numberHeight, options) {
CAL.Matrix.call(this, options);
this.visible = options.visible !== undefined ? options.visible : true;
this.active = options.active || false;
this.depth = options.depth || 0;
this.alpha = (typeof options.alpha === "number") ? options.alpha : 1;
this.centerX = centerX || 0;
this.centerY = centerY || 0;
this.index = 0;
this.numberWidth = numberWidth || 1;
this.numberHeight = numberHeight || 1;
this.length = this.numberWidth*this.numberHeight;
};
CAL.Draw.prototype = Object.create(CAL.Matrix.prototype);
CAL.Draw.prototype.draw = function (context, matrix) {
context.save();
(matrix || this).setContext(context);
context.globalAlpha = this.alpha;
this.drawSimple(context, this.index, 0, 0);
context.restore();
};
CAL.Draw.prototype.drawSimple = function (context, number, x, y) {
var sx = (number % this.numberWidth)*this.width;
var sy = Math.floor(number/this.numberWidth)*this.height;
context.drawImage(this.image, sx, sy, this.width, this.height, x-this.centerX, y-this.centerY, this.width, this.height);
};
CAL.Draw.prototype.drawAlpha = function (context, number, x, y, alpha) {
context.globalAlpha = alpha;
this.drawSimple(context, number, x, y);
context.globalAlpha = 1;
};
CAL.Draw.prototype.drawAngle = function (context, number, x, y, angle) {
context.save();
context.translate(x, y);
context.rotate(angle);
this.drawSimple(context, number, 0, 0);
context.restore();
};
CAL.Draw.prototype.drawScale = function (context, number, x, y, width, height) {
var sx = (number % this.numberWidth)*this.width;
var sy = Math.floor(number/this.numberWidth)*this.height;
context.drawImage(this.image, sx, sy, this.width, this.height, x-this.centerX, y-this.centerY, width, height);
};
CAL.Draw.prototype.drawContain = function (context, number, x, y, width, height) {
if (width/height > this.width/this.height) {
x = x + (width-height/this.height*this.width)/2;
width = height/this.height*this.width;
this.drawScale(context, number, x, y, width, height);
}
else {
y = y + (height-width/this.width*this.height)/2;
height = width/this.width*this.height;
this.drawScale(context, number, x, y, width, height);
}
};
CAL.Surface = function (options) {
options = options || {};
CAL.Draw.call(this, options.centerX, options.centerY, options.numberWidth, options.numberHeight, options);
this.clearColor = options.clearColor || false;
this.setCanvas(options.canvas || document.createElement("canvas"));
this.setSize(options.width, options.height);
};
CAL.Surface.prototype = Object.create(CAL.Draw.prototype);
CAL.Surface.prototype.setSize = function (width, height) {
this.image.width = width || this.image.width;
this.image.height = height || this.image.height;
this.width = this.image.width/this.numberWidth;
this.height = this.image.height/this.numberHeight;
};
CAL.Surface.prototype.setCanvas = function (canvas) {
this.image = canvas;
this.context = canvas.getContext("2d");
};
CAL.Surface.prototype.clear = function () {
if (this.clearColor) {
this.clearColor.setColor(this.context);
this.context.fillRect(0, 0, this.image.width, this.image.height);
}
else {
this.context.clearRect(0, 0, this.image.width, this.image.height);
}
};
CAL.Surface.prototype.getImageData = function (x, y, width, height) {
var x = x || 0;
var y = y || 0;
var width = width || this.image.width;
var height = height || this.image.height;
return this.context.getImageData(x, y, width, height);
};
CAL.Surface.prototype.getDataURL = function () {
return this.image.toDataURL();
};
CAL.Surface.prototype.blur = (function () {
//source: http://www.quasimondo.com/StackBlurForCanvas/StackBlurDemo.html
//author: Mario Klingemann
var mul_table = [512,512,456,512,328,456,335,512,405,328,271,456,388,335,292,512,454,405,364,328,298,271,496,456,420,388,360,335,312,292,273,512,482,454,428,405,383,364,345,328,312,298,284,271,259,496,475,456,437,420,404,388,374,360,347,335,323,312,302,292,282,273,265,512,497,482,468,454,441,428,417,405,394,383,373,364,354,345,337,328,320,312,305,298,291,284,278,271,265,259,507,496,485,475,465,456,446,437,428,420,412,404,396,388,381,374,367,360,354,347,341,335,329,323,318,312,307,302,297,292,287,282,278,273,269,265,261,512,505,497,489,482,475,468,461,454,447,441,435,428,422,417,411,405,399,394,389,383,378,373,368,364,359,354,350,345,341,337,332,328,324,320,316,312,309,305,301,298,294,291,287,284,281,278,274,271,268,265,262,259,257,507,501,496,491,485,480,475,470,465,460,456,451,446,442,437,433,428,424,420,416,412,408,404,400,396,392,388,385,381,377,374,370,367,363,360,357,354,350,347,344,341,338,335,332,329,326,323,320,318,315,312,310,307,304,302,299,297,294,292,289,287,285,282,280,278,275,273,271,269,267,265,263,261,259];
var shg_table = [9,11,12,13,13,14,14,15,15,15,15,16,16,16,16,17,17,17,17,17,17,17,18,18,18,18,18,18,18,18,18,19,19,19,19,19,19,19,19,19,19,19,19,19,19,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24 ];
return function (radius, x, y, width, height) {
x = x || 0;
y = y || 0;
width = this.image.width || 0;
height = this.image.height || 0;
var imageData = this.getImageData(x, y, width, height);
var x, y, i, p, yp, yi, yw, r_sum, g_sum, b_sum, a_sum,
r_out_sum, g_out_sum, b_out_sum, a_out_sum,
r_in_sum, g_in_sum, b_in_sum, a_in_sum,
pr, pg, pb, pa, rbs;
var div = radius + radius + 1;
var w4 = width << 2;
var widthMinus1 = width - 1;
var heightMinus1 = height - 1;
var radiusPlus1 = radius + 1;
var sumFactor = radiusPlus1 * (radiusPlus1 + 1) / 2;
var pixels = imageData.data;
var stackStart = {r: 0, g: 0, b: 0, next: null};
var stack = stackStart;
for (i = 1; i < div; i ++) {
stack = stack.next = {r: 0, g: 0, b: 0, next: null};
if (i == radiusPlus1) {
var stackEnd = stack;
}
}
stack.next = stackStart;
var stackIn = null;
var stackOut = null;
yw = yi = 0;
var mul_sum = mul_table[radius];
var shg_sum = shg_table[radius];
for (y = 0; y < height; y ++) {
r_in_sum = g_in_sum = b_in_sum = a_in_sum = r_sum = g_sum = b_sum = a_sum = 0;
r_out_sum = radiusPlus1 * (pr = pixels[yi]);
g_out_sum = radiusPlus1 * (pg = pixels[yi+1]);
b_out_sum = radiusPlus1 * (pb = pixels[yi+2]);
a_out_sum = radiusPlus1 * (pa = pixels[yi+3]);
r_sum += sumFactor * pr;
g_sum += sumFactor * pg;
b_sum += sumFactor * pb;
a_sum += sumFactor * pa;
stack = stackStart;
for (i = 0; i < radiusPlus1; i ++) {
stack.r = pr;
stack.g = pg;
stack.b = pb;
stack.a = pa;
stack = stack.next;
}
for (i = 1; i < radiusPlus1; i ++) {
p = yi + ((widthMinus1 < i ? widthMinus1 : i) << 2);
r_sum += (stack.r = (pr = pixels[p])) * (rbs = radiusPlus1 - i);
g_sum += (stack.g = (pg = pixels[p+1])) * rbs;
b_sum += (stack.b = (pb = pixels[p+2])) * rbs;
a_sum += (stack.a = (pa = pixels[p+3])) * rbs;
r_in_sum += pr;
g_in_sum += pg;
b_in_sum += pb;
a_in_sum += pa;
stack = stack.next;
}
stackIn = stackStart;
stackOut = stackEnd;
for (x = 0; x < width; x ++) {
pixels[yi+3] = pa = (a_sum * mul_sum) >> shg_sum;
if (pa === 0) {
pixels[yi] = pixels[yi+1] = pixels[yi+2] = 0;
}
else {
pa = 255 / pa;
pixels[yi] = ((r_sum * mul_sum) >> shg_sum) * pa;
pixels[yi+1] = ((g_sum * mul_sum) >> shg_sum) * pa;
pixels[yi+2] = ((b_sum * mul_sum) >> shg_sum) * pa;
}
r_sum -= r_out_sum;
g_sum -= g_out_sum;
b_sum -= b_out_sum;
a_sum -= a_out_sum;
r_out_sum -= stackIn.r;
g_out_sum -= stackIn.g;
b_out_sum -= stackIn.b;
a_out_sum -= stackIn.a;
p = (yw + ((p = x + radius + 1) < widthMinus1 ? p : widthMinus1)) << 2;
r_in_sum += (stackIn.r = pixels[p]);
g_in_sum += (stackIn.g = pixels[p+1]);
b_in_sum += (stackIn.b = pixels[p+2]);
a_in_sum += (stackIn.a = pixels[p+3]);
r_sum += r_in_sum;
g_sum += g_in_sum;
b_sum += b_in_sum;
a_sum += a_in_sum;
stackIn = stackIn.next;
r_out_sum += (pr = stackOut.r);
g_out_sum += (pg = stackOut.g);
b_out_sum += (pb = stackOut.b);
a_out_sum += (pa = stackOut.a);
r_in_sum -= pr;
g_in_sum -= pg;
b_in_sum -= pb;
a_in_sum -= pa;
stackOut = stackOut.next;
yi += 4;
}
yw += width;
}
for (x = 0; x < width; x ++) {
g_in_sum = b_in_sum = a_in_sum = r_in_sum = g_sum = b_sum = a_sum = r_sum = 0;
yi = x << 2;
r_out_sum = radiusPlus1 * (pr = pixels[yi]);
g_out_sum = radiusPlus1 * (pg = pixels[yi+1]);
b_out_sum = radiusPlus1 * (pb = pixels[yi+2]);
a_out_sum = radiusPlus1 * (pa = pixels[yi+3]);
r_sum += sumFactor * pr;
g_sum += sumFactor * pg;
b_sum += sumFactor * pb;
a_sum += sumFactor * pa;
stack = stackStart;
for (i = 0; i < radiusPlus1; i ++) {
stack.r = pr;
stack.g = pg;
stack.b = pb;
stack.a = pa;
stack = stack.next;
}
yp = width;
for (i = 1; i <= radius; i ++) {
yi = (yp + x) << 2;
r_sum += (stack.r = (pr = pixels[yi])) * (rbs = radiusPlus1 - i);
g_sum += (stack.g = (pg = pixels[yi+1])) * rbs;
b_sum += (stack.b = (pb = pixels[yi+2])) * rbs;
a_sum += (stack.a = (pa = pixels[yi+3])) * rbs;
r_in_sum += pr;
g_in_sum += pg;
b_in_sum += pb;
a_in_sum += pa;
stack = stack.next;
if (i < heightMinus1) {
yp += width;
}
}
yi = x;
stackIn = stackStart;
stackOut = stackEnd;
for (y = 0; y < height; y ++) {
p = yi << 2;
pixels[p+3] = pa = (a_sum * mul_sum) >> shg_sum;
if (pa > 0) {
pa = 255 / pa;
pixels[p] = ((r_sum * mul_sum) >> shg_sum) * pa;
pixels[p+1] = ((g_sum * mul_sum) >> shg_sum) * pa;
pixels[p+2] = ((b_sum * mul_sum) >> shg_sum) * pa;
}
else {
pixels[p] = pixels[p+1] = pixels[p+2] = 0;
}
r_sum -= r_out_sum;
g_sum -= g_out_sum;
b_sum -= b_out_sum;
a_sum -= a_out_sum;
r_out_sum -= stackIn.r;
g_out_sum -= stackIn.g;
b_out_sum -= stackIn.b;
a_out_sum -= stackIn.a;
p = (x + (((p = y + radiusPlus1) < heightMinus1 ? p : heightMinus1) * width)) << 2;
r_sum += (r_in_sum += (stackIn.r = pixels[p]));
g_sum += (g_in_sum += (stackIn.g = pixels[p+1]));
b_sum += (b_in_sum += (stackIn.b = pixels[p+2]));
a_sum += (a_in_sum += (stackIn.a = pixels[p+3]));
stackIn = stackIn.next;
r_out_sum += (pr = stackOut.r);
g_out_sum += (pg = stackOut.g);
b_out_sum += (pb = stackOut.b);
a_out_sum += (pa = stackOut.a);
r_in_sum -= pr;
g_in_sum -= pg;
b_in_sum -= pb;
a_in_sum -= pa;
stackOut = stackOut.next;
yi += width;
}
}
return imageData;
};
})();
CAL.Draw.prototype.drawBlur = (function () {
var surface = new CAL.Surface();
return function (context, number, x, y, radius) {
if (radius > 0) {
surface.setSize(this.width + 2*radius, this.height + 2*radius);
this.drawSimple(surface.context, number, this.centerX+radius, this.centerY+radius);
var imageData = surface.blur(radius);
context.putImageData(imageData, x-this.centerX - radius, y-this.centerY - radius);
/*surface.setSize(this.width, this.height);
this.drawSimple(surface.context, number, this.centerX, this.centerY);
var imageData = surface.blur(radius);
context.putImageData(imageData, x-this.centerX, y-this.centerY);*/
}
else {
this.drawSimple(context, number, x, y);
}
};
})();
CAL.Group = function (options) {
options = options || {};
CAL.Surface.call(this, options);
this.active = true;
this.visible = true;
this.objects = [];
this.useCanvas = options.useCanvas || false;
this.clearCanvas = true;
this.drawCanvas = true;
this.mouse = {
x: null,
y: null,
startX: null,
startY: null,
deltaX: null,
deltaY: null,
down: false,
moved: false
};
};
CAL.Group.prototype = Object.create(CAL.Surface.prototype);
CAL.Group.prototype.updateEvents = function () {
var scope = this;
this.image.onmousedown = function (event) {
if (scope.useCanvas) {
scope.mouse.x = scope.mouse.startX = Math.round(scope.image.width / scope.image.clientWidth * event.offsetX);
scope.mouse.y = scope.mouse.startY = Math.round(scope.image.height / scope.image.clientHeight * event.offsetY);
scope.mouse.deltaX = 0;
scope.mouse.deltaY = 0;
scope.mouse.down = true;
scope.mouse.moved = false;
scope.mouseDown(scope.mouse, this);
}
};
this.image.onmouseup = function (event) {
if (scope.useCanvas) {
scope.mouse.x = Math.round(scope.image.width / scope.image.clientWidth * event.offsetX);
scope.mouse.y = Math.round(scope.image.height / scope.image.clientHeight * event.offsetY);
scope.mouse.down = false;
scope.mouseUp(scope.mouse, this);
scope.mouse.startX = null;
scope.mouse.startY = null;
scope.mouse.deltaX = null;
scope.mouse.deltaY = null;
scope.mouse.moved = false;
}
};
this.image.onmousemove = function (event) {
if (scope.useCanvas) {
scope.mouse.x = Math.round(scope.image.width / scope.image.clientWidth * event.offsetX);
scope.mouse.y = Math.round(scope.image.height / scope.image.clientHeight * event.offsetY);
if (scope.mouse.down) {
scope.mouse.moved = true;
scope.mouse.deltaX = scope.mouse.x - scope.mouse.startX;
scope.mouse.deltaY = scope.mouse.y - scope.mouse.startY;
}
}
};
//this.image.ontouchstart = function (event) {scope.touchStart(event);};
//this.image.ontouchmove = function (event) {scope.touchMove(event);};
//this.image.ontouchend = function (event) {scope.touchEnd(event);};
};
CAL.Group.prototype.setCanvas = function (canvas) {
/*this.image.onmousedown = null;
this.image.onmouseup = null;
this.image.onmousemove = null;
this.image.ontouchstart = null;
this.image.ontouchmove = null;
this.image.ontouchend = null;*/
this.image = canvas;
this.context = canvas.getContext("2d");
this.drawCanvas = true;
this.updateEvents();
};
CAL.Group.prototype.add = function () {
for (var i = 0; i < arguments.length; i ++) {
var object = arguments[i];
if (this.objects.indexOf(object) === -1) {
this.objects.push(object);
if (object.init) {
object.init(this);
}
}
}
this.sort();
this.drawCanvas = true;
};
CAL.Group.prototype.remove = function () {
for (var i = 0; i < arguments.length; i ++) {
var object = arguments[i];
this.objects.remove(object);
if (object.active && object.remove !== undefined) {
object.remove(this);
}
}
this.drawCanvas = true;
};
CAL.Group.prototype.sort = function () {
this.objects.sort(function (a, b) {
return (a.depth || 0) - (b.depth || 0);
});
};
CAL.Group.prototype.keyDown = function (keyCode) {
for (var i = this.objects.length-1; i >= 0; i --) {
var object = this.objects[i];
if (object.active && object.keyDown !== undefined) {
if (object.keyDown(keyCode, this)) {
break;
}
}
}
};
CAL.Group.prototype.keyUp = function (keyCode) {
for (var i = this.objects.length-1; i >= 0; i --) {
var object = this.objects[i];
if (object.active && object.keyUp !== undefined) {
if (object.keyUp(keyCode, this)) {
break;
}
}
}
};
CAL.Group.prototype.mouseDown = function (mouse) {
for (var i = this.objects.length-1; i >= 0; i --) {
var object = this.objects[i];
if (object.useCanvas !== true && object.active && object.mouseDown !== undefined) {
if (object.mouseDown(mouse, this)) {
break;
}
}
}
};
CAL.Group.prototype.mouseUp = function (mouse) {
for (var i = this.objects.length-1; i >= 0; i --) {
var object = this.objects[i];
if (object.useCanvas !== true && object.active && object.mouseUp !== undefined) {
if (object.mouseUp(mouse, this)) {
break;
}
}
}
};
CAL.Group.prototype.step = function (deltaTime) {
for (var i = 0; i < this.objects.length; i ++) {
var object = this.objects[i];
if (object.active && object.step !== undefined) {
object.step(deltaTime, this);
}
}
if (this.clearCanvas && this.useCanvas) {
this.clear();
}
if (this.drawCanvas && this.useCanvas) {
this.draw();
}
this.clearCanvas = false;
this.drawCanvas = false;
};
CAL.Group.prototype.draw = function (context, matrix) {
context = this.useCanvas ? this.context : context;
matrix = this.useCanvas ? this : matrix;
for (var i = 0; i < this.objects.length; i ++) {
var object = this.objects[i];
if (object.useCanvas !== true && object.visible && object.draw !== undefined) {
if (object instanceof CAL.Matrix) {
object.draw(context, matrix.multiplyMatrix(object));
}
else {
object.draw(context, matrix);
}
}
}
};
CAL.Scene = function () {
CAL.Group.call(this, {useCanvas: true});
this.lastTime = new Date().getTime();
this.keysDown = [];
this.focus = true;
var scope = this;
window.onkeydown = function (event) {
if (!scope.keysDown[event.keyCode]) {
scope.keysDown[event.keyCode] = true;
scope.keyDown(event.keyCode);
}
};
window.onkeyup = function (event) {
scope.keysDown[event.keyCode] = false;
scope.keyUp(event.keyCode);
};
window.onblur = function (event) {
this.focus = false;
};
window.onfocus = function (event) {
scope.lastTime = new Date().getTime();
this.focus = true;
};
};
CAL.Scene.prototype = Object.create(CAL.Group.prototype);
CAL.Scene.prototype.cycle = function () {
if (this.focus) {
var currentTime = new Date().getTime();
var deltaTime = currentTime-this.lastTime;
this.lastTime = currentTime;
this.step(deltaTime);
}
};
CAL.Scene = new CAL.Scene();
CAL.Image = function (source, centerX, centerY, numberWidth, numberHeight, options) {
options = options || {};
CAL.Draw.call(this, centerX, centerY, numberWidth, numberHeight, options);
this.image = new Image();
this.source = source;
};
CAL.Image.prototype = Object.create(CAL.Draw.prototype);
CAL.Image.prototype.load = function (callback) {
var scope = this;
this.image.onload = function () {
scope.loaded = true;
scope.width = scope.image.width/scope.numberWidth;
scope.height = scope.image.height/scope.numberHeight;
if (callback !== undefined) {
callback();
}
};
this.image.src = this.source;
};
CAL.ImageLoader = function () {
this.images = [];
for (var i = 0; i < arguments.length; i ++) {
var image = arguments[i];
this.images.push(image);
}
};
CAL.ImageLoader.prototype.add = function () {
for (var i = 0; i < arguments.length; i ++) {
var image = arguments[i];
if (this.images.indexOf(image) === -1) {
this.images.push(image);
}
}
};
CAL.ImageLoader.prototype.remove = function () {
for (var i = 0; i < arguments.length; i ++) {
var image = arguments[i];
this.images.remove(image);
}
};
CAL.ImageLoader.prototype.load = function (callback) {
var imagesToLoad = this.images.length;
for (var i = 0; i < this.images.length; i ++) {
var image = this.images[i];
image.load(function () {
imagesToLoad --;
if (imagesToLoad === 0 && callback !== undefined) {
callback();
}
}, this);
};
};
CAL.Color = function () {
if (typeof arguments[0] === "number" && typeof arguments[1] === "number" && typeof arguments[2] === "number") {
this.r = arguments[0];
this.g = arguments[1];
this.b = arguments[2];
this.a = typeof arguments[3] === "number" ? arguments[3] : 1;
}
else if (typeof arguments[0] === "number") {
var hex = Math.floor(arguments[0]);
this.r = hex >> 16 & 255;
this.g = hex >> 8 & 255;
this.b = hex & 255;
this.a = 1;
}
else {
this.r = 0;
this.g = 0;
this.b = 0;
this.a = 1;
}
};
CAL.Color.prototype.setStroke = function (context) {
context.strokeStyle = "rgba("+this.r+", "+this.g+", "+this.b+", "+this.a+")";
};
CAL.Color.prototype.setFill = function (context) {
context.fillStyle = "rgba("+this.r+", "+this.g+", "+this.b+", "+this.a+")";
};
CAL.Color.prototype.setColor = function (context) {
this.setStroke(context);
this.setFill(context);
};
CAL.Tween = function (object, attributes, duration, options) {
options = options || {};
this.visible = false;
this.active = true;
this.depth = -10000;
this.object = object;
this.attributes = attributes;
this.timer = 0;
this.duration = duration;
this.easing = options.easing || CAL.Easings.linear;
this.callback = options.callback;
this.begin = {};
for (var i in attributes) {
this.begin[i] = this.object[i];
}
this.change = {};
for (var i in attributes) {
this.change[i] = attributes[i] - this.begin[i];
}
this.drawCanvas = options.drawCanvas !== undefined ? options.drawCanvas : true;
this.clearCanvas = options.clearCanvas !== undefined ? options.clearCanvas : false;
};
CAL.Tween.prototype.start = function () {
this.t = 0;
this.active = true;
};
CAL.Tween.prototype.stop = function () {
this.t = 0;
this.active = false;
};
CAL.Tween.prototype.pause = function () {
this.active = false;
};
CAL.Tween.prototype.resume = function () {
this.active = true;
};
CAL.Tween.prototype.step = function (deltaTime, group) {
this.timer += deltaTime;
if (this.timer < this.duration) {
for (var i in this.attributes) {
var dt = this.timer;
var d = this.duration;
var b = this.begin[i];
var c = this.change[i];
this.object[i] = this.easing(dt, b, c, d);
}
}
else {
for (var i in this.attributes) {
this.object[i] = this.attributes[i];
}
if (this.callback !== undefined) {
this.callback();
}
group.remove(this);
}
if (this.clearCanvas) {
group.clearCanvas = true;
}
if (this.drawCanvas) {
group.drawCanvas = true;
}
};
CAL.TimeLine = function (options) {
options = options || {};
this.visible = false;
this.active = true;
this.depth = -10000;
this.moments = [];
this.autoRemove = (options.autoRemove !== undefined) ? options.autoremove : true;
this.loop = (options.loop !== undefined) ? options.loop : false;
this.t = 0;
CAL.Scene.add(this);
};
CAL.TimeLine.prototype = {
addMoment: function (time, callback) {
this.moments.push({
time: time,
callback: callback
});
},
removeMoment: function (remove) {
for (var i = 0; i < this.moments.length; i ++) {
var moment = this.moments[i];
if (moment === remove || moment.time === remove || moment.callback === remove) {
this.moments.remove(moment);
}
}
},
start: function () {
this.t = 0;
this.active = true;
},
stop: function () {
this.t = 0;
this.active = false;
},
pause: function () {
this.active = false;
},
resume: function () {
this.active = true;
},
step: function (dt) {
var newTime = this.t + dt;
var remove = true;
for (var i = 0; i < this.moments.length; i ++) {
var moment = this.moments[i];
if (moment.time >= this.t) {
if (moment.time < newTime) {
moment.callback();
}
else {
remove = false;
}
}
}
if (remove && this.loop) {
this.t = 0;
}
else if (remove && this.autoRemove) {
CAL.Scene.remove(this);
}
this.t = newTime;
}
};
CAL.Shape = function (options) {
options = options || {};
CAL.Matrix.call(this, options);
this.visible = options.visible !== undefined ? options.visible : true;
this.active = false;
this.depth = options.depth || 0;
this.lines = [];
this.closePath = options.closePath !== undefined ? options.closePath : true;
this.lineColor = options.lineColor !== undefined ? options.lineColor : new CAL.Color();
this.shapeColor = options.shapeColor !== undefined ? options.shapeColor : new CAL.Color();
this.lineWidth = options.lineWidth || 1;
this.lineJoin = options.lineJoin || "miter";
this.lineCap = options.lineCap || "square";
this.points = options.points || [];
};
CAL.Shape.prototype = Object.create(CAL.Matrix.prototype);
CAL.Shape.prototype.addPoint = function () {
for (var i = 0; i < arguments.length; i ++) {
var point = arguments[i];
this.points.push(point);
}
//this.update();
};
CAL.Shape.prototype.hit = function (x, y) {
for (var i = 0; i < this.points.length; i ++) {
if (new CAL.Vector(x, y).subtract(this.points[i].applyMatrix(this)).dot(this.getNormal(i)) > 0) {
return false;
}
}
return true;
};
CAL.Shape.prototype.setContext = function (context, matrix) {
var matrix = matrix || this;
context.beginPath();
for (var i = 0; i < this.points.length; i ++) {
var point = this.points[i].applyMatrix(matrix);
context.lineTo(point.x, point.y);
}
if (this.closePath) {
context.closePath();
}
};
CAL.Shape.prototype.getBoundingBox = function () {
var minX = Infinity;
var minY = Infinity;
var maxX = -Infinity;
var maxY = -Infinity;
for (var i = 0; i < this.points.length; i ++) {
var point = this.points[i];
minX = point.x < minX ? point.x : minX;
minY = point.y < minY ? point.y : minY;
maxX = point.x > maxX ? point.x : maxX;
maxY = point.y > maxY ? point.y : maxY;
};
return {x: minX, y: minY, width: maxX-minX, height: maxY-minY};
};
CAL.Shape.prototype.getNormal = function (i) {
var pointA = this.points[(i+1)%this.points.length].applyMatrix(this);
var pointB = this.points[i].applyMatrix(this);
return pointA.subtract(pointB).normal().normalize();
};
CAL.Shape.prototype.clip = function (context, matrix) {
this.setContext(context, matrix);
context.clip();
};
CAL.Shape.prototype.fill = function (context, matrix) {
this.setContext(context, matrix);
this.shapeColor.setFill(context);
context.fill();
};
CAL.Shape.prototype.stroke = function (context, matrix) {
this.setContext(context, matrix);
context.lineColor = this.lineColor;
context.lineWidth = this.lineWidth;
context.lineJoin = this.lineJoin;
context.lineCap = this.lineCap;
this.lineColor.setStroke(context);
context.stroke();
};
CAL.Shape.prototype.draw = function (context, matrix) {
this.setContext(context, matrix);
if (this.shapeColor) {
this.shapeColor.setFill(context);
context.fill();
}
if (this.lineColor) {
context.lineColor = this.lineColor;
context.lineWidth = this.lineWidth;
context.lineJoin = this.lineJoin;
context.lineCap = this.lineCap;
this.lineColor.setStroke(context);
context.stroke();
}
};
CAL.BezierPoint = function (position, controlPointA, controlPointB) {
this.position = position || new CAL.Vector(0, 0);
this.controlPointA = controlPointA || new CAL.Vector(0, 0);
this.controlPointB = controlPointB || new CAL.Vector(0, 0);
}
CAL.BezierPoint.prototype.applyMatrix = function (matrix) {
var position = this.position.applyMatrix(matrix);
var controlPointA = this.controlPointA.applyMatrix(matrix);
var controlPointB = this.controlPointB.applyMatrix(matrix);
return new CAL.BezierPoint(position, controlPointA, controlPointB);
};
CAL.BezierPoint.prototype.draw = function (context) {
var leftHandle = this.controlPointA.add(this.position);
var rightHandle = this.controlPointB.add(this.position);
context.strokeStyle = "#09F";
context.beginPath();
context.moveTo(leftHandle.x, leftHandle.y);
context.lineTo(this.position.x, this.position.y);
context.lineTo(rightHandle.x, rightHandle.y);
context.stroke();
context.beginPath();
context.arc(this.position.x, this.position.y, 10, 0, Math.PI*2, true);
context.stroke();
context.beginPath();
context.arc(leftHandle.x, leftHandle.y, 5, 0, Math.PI*2, true);
context.stroke();
context.beginPath();
context.arc(rightHandle.x, rightHandle.y, 5, 0, Math.PI*2, true);
context.stroke();
};
/*CAL.Shape = function (options) {
options = options || {};
CAL.Matrix.call(this, options);
this.visible = options.visible !== undefined ? options.visible : true;
this.active = false;
this.depth = options.depth || 0;
this.closePath = options.closePath !== undefined ? options.closePath : true;
this.lineColor = options.lineColor !== undefined ? options.lineColor : new CAL.Color();
this.shapeColor = options.shapeColor !== undefined ? options.shapeColor : new CAL.Color();
this.lineWidth = options.lineWidth || 1;
this.lineJoin = options.lineJoin || "miter";
this.lineCap = options.lineCap || "square";
this.points = options.points || [];
this.precision = options.precision || 3;
this.lines = [];
this.length = 0;
this.closed = false;
}
CAL.Shape.prototype.init = function (group) {
for (var i = 0; i < this.points.length; i ++) {
var point = this.points[i];
if (point instanceof CAL.Vector) {
point = new CAL.BezierPoint(point);
}
this.points[i] = point;
}
this.update();
};
CAL.Shape.prototype.addPoint = function () {
for (var i = 0; i < arguments.length; i ++) {
var point = arguments[i];
if (point instanceof CAL.Vector) {
point = new CAL.BezierPoint(point);
}
if (point instanceof CAL.BezierPoint) {
this.points.push(point);
}
}
this.update();
};
CAL.Shape.prototype.collisionBox = function (vec1, vec2) {
for (var i = 0; i < this.lines.length; i ++) {
var point = this.lines[i];
if (point.x > vec1.x && point.y > vec1.y && point.x < vec2.x && point.y < vec2.y) {
return true;
}
}
return false;
};
CAL.Shape.prototype.getNormal = function (i) {
var pointA = this.lines[(i+1)%this.lines.length].applyMatrix(this);
var pointB = this.lines[i].applyMatrix(this);
return pointA.subtract(pointB).normal().normalize();
};
CAL.Shape.prototype.collisionPoint = function (x, y) {
for (var i = 0; i < this.lines.length; i ++) {
if (new CAL.Vector(x, y).subtract(this.lines[i].applyMatrix(this)).dot(this.getNormal(i)) > 0) {
return false;
}
}
return true;
};
CAL.Shape.prototype.removePoint = function () {
for (var i = 0; i < arguments.length; i ++) {
var argument = arguments[i];
if (typeof argument === "number") {
var index = argument;
}
else if (argument instanceof CAL.BezierPoint || argument instanceof CAL.Vector) {
var index = this.getPointIndex(argument);
}
if (index !== -1) {
this.points.splice(index, 1);
}
}
this.update();
};
CAL.Shape.prototype.getPointIndex = function (point) {
if (point instanceof CAL.BezierPoint) {
return this.points.indexOf(argument);
}
else if (point instanceof CAL.Vector) {
for (i = 0; i < this.points.length; i ++) {
var length = this.points[i].position.subtract(point).length();
if (length === 0) {
return i;
}
}
return -1;
}
};
CAL.Shape.prototype.numberPoints = function () {
return this.points.length;
};
CAL.Shape.prototype.insertPoint = function (point, index) {
if (point instanceof CAL.Vector) {
point = new CAL.BezierPoint(point);
}
if (point instanceof CAL.BezierPoint) {
this.points.splice(index, 0, point);
this.update();
}
};
CAL.Shape.prototype.setClosed = function (closed) {
this.closed = closed;
this.update();
};
CAL.Shape.prototype.setPrecision = function (precision) {
this.precision = precision;
this.update();
};
CAL.Shape.prototype.makeSmooth = function (strength, start, end) {
start = start || 0;
end = end || this.points.length;
if (this.closed === false) {
start = Math.max(start, 1);
end = Math.min(end, this.points.length-1);
}
else {
start = Math.max(start, 0);
end = Math.min(end, this.points.length);
}
for (var i = start; i < end; i ++) {
var p0 = this.points[i-1];
var p1 = this.points[i];
var p2 = this.points[i+1];
if (typeof(p0) === "undefined") {
p0 = this.points[this.points.length-1];
}
else if (typeof(p2) === "undefined") {
p2 = this.points[0];
}
var a = p0.position.subtract(p1.position);
var b = p2.position.subtract(p1.position);
var length = (a.length()+b.length())/4;
var direction = a.normalize().add(b.scale(-1).normalize()).normalize();
p1.controlPointA = direction.scale(length*strength);
p1.controlPointB = direction.scale(-length*strength);
}
this.update();
};
CAL.Shape.prototype.calculateBezierPoints = function (p0, p1) {
var array = [];
if (p0.controlPointB.length() === 0 && p1.controlPointA.length() === 0) {
var angle = p1.position.subtract(p0.position).angle();
array.push({
x: p0.position.x,
y: p0.position.y,
angle: angle
}, {
x: p1.position.x,
y: p1.position.y,
angle: angle
});
}
else {
var point = {
x: p1.position.x,
y: p1.position.y,
angle: p1.controlPointB.direction()
}
array = array.concat(
recursiveBezier(
p0.position,
p0.position.add(p0.controlPointB),
p1.position.add(p1.controlPointA),
p1.position,
this.precision
),
[point]
);
}
return array;
};
CAL.Shape.prototype.update = function () {
if (this.points.length >= 2) {
if (this.points[0].controlPointB.length() !== 0) {
var point = {
x: this.points[0].position.x,
y: this.points[0].position.y,
angle: this.points[0].controlPointB.direction()
};
this.lines = [point];
}
for (var i = 0; i < this.points.length-1; i ++) {
var p0 = this.points[i];
var p1 = this.points[i+1];
this.lines = this.lines.concat(this.calculateBezierPoints(p0, p1));
}
if (this.closed === true) {
var p0 = this.points[this.points.length-1];
var p1 = this.points[0];
this.lines = this.lines.concat(this.calculateBezierPoints(p0, p1));
}
var pathLength = 0;
this.lines[0].position = 0;
for (var i = 0; i < this.lines.length-1; i ++) {
var p0 = this.lines[i];
var p1 = this.lines[i+1];
var line = new CAL.Vector(p1.x, p1.y).subtract(p0);
pathLength += line.length();
p1.position = pathLength;
}
this.length = pathLength;
}
};
CAL.Shape.prototype.getPosition = function (t) {
var t = Math.max(Math.min(t, this.length), 0);
for (var i = 1; true; i ++) {
var p0 = this.lines[i-1];
var p1 = this.lines[i];
if (p1.position >= t) {
t = (t-p0.position) / (p1.position-p0.position);
var position = new CAL.Vector(p0.x, p0.y).scale(1-t).add(new CAL.Vector(p1.x, p1.y).scale(t));
var angle = p0.angle + ((((p1.angle-p0.angle)%360)+540)%360-180)*t;
return {
x: position.x,
y: position.y,
angle: angle
};
}
}
};
CAL.Shape.prototype.setContextPart = function (context, begin, end) {
var beginPos = this.getPosition(begin);
var endPos = this.getPosition(end);
context.beginPath();
context.moveTo(beginPos.x, beginPos.y);
for (var i = 0; i < this.lines.length; i ++) {
var line = this.lines[i];
if (line.position > begin) {
context.lineTo(line.x, line.y);
if (line.position > end) {
break;
}
}
}
context.lineTo(endPos.x, endPos.y);
};
CAL.Shape.prototype.setContext = function (context) {
this.setContextPart(context, 0, this.length);
};
CAL.Shape.prototype.setClippingPart = function (context, begin, end) {
context.save();
this.setContextPart(begin, end);
context.clip();
};
CAL.Shape.prototype.setClipping = function (context) {
this.setClippingPart(context, 0, this.length);
};
CAL.Shape.prototype.drawPart = function (context, begin, end, color, width, cap) {
this.setContextPart(context, begin, end);
context.strokeStyle = color || "black";
context.lineWidth = width || 1;
context.lineCap = cap || 'butt';
context.stroke();
};
CAL.Shape.prototype.setContext = function (context, matrix) {
var matrix = matrix || this;
context.beginPath();
for (var i = 0; i < this.lines.length; i ++) {
var point = this.lines[i]//.applyMatrix(matrix);
context.lineTo(point.x, point.y);
}
if (this.closePath) {
context.closePath();
}
};
CAL.Shape.prototype.fill = function (context, matrix) {
this.setContext(context, matrix);
this.shapeColor.setFill(context);
context.fill();
};
CAL.Shape.prototype.stroke = function (context, matrix) {
this.setContext(context, matrix);
context.lineColor = this.lineColor;
context.lineWidth = this.lineWidth;
context.lineJoin = this.lineJoin;
context.lineCap = this.lineCap;
this.lineColor.setStroke(context);
context.stroke();
};
CAL.Shape.prototype.draw = function (context, matrix) {
if (this.shapeColor) {
this.shapeColor.setFill(context);
context.fill();
}
if (this.lineColor) {
this.stroke(context, matrix);
}
this.debugDraw(context);
};
CAL.Shape.prototype.debugDraw = function (context) {
context.beginPath();
context.lineWidth = 1;
for (var i = 0; i < this.points.length; i ++) {
var point = this.points[i];
point.draw(context);
}
context.beginPath();
for (var i = 0; i < this.lines.length; i ++) {
var point = this.lines[i];
context.lineTo(point.x, point.y);
context.arc(point.x, point.y, 2, 0, Math.PI*2, true);
context.lineTo(point.x, point.y);
}
context.strokeStyle = "black";
context.stroke();
};
CAL.Shape.prototype.getSize = function () {
var width = 0;
var height = 0;
for (var i = 0; i < this.lines.length; i ++) {
var line = this.lines[i];
width = Math.max(width, Math.ceil(line.x));
height = Math.max(width, Math.ceil(line.y));
}
return {
width: width,
height: height
};
};
CAL.BezierPoint = function (position, controlPointA, controlPointB) {
this.position = position || new CAL.Vector(0, 0);
this.controlPointA = controlPointA || new CAL.Vector(0, 0);
this.controlPointB = controlPointB || new CAL.Vector(0, 0);
}
CAL.BezierPoint.prototype.applyMatrix = function (matrix) {
var position = this.position.applyMatrix(matrix);
var controlPointA = this.controlPointA.applyMatrix(matrix);
var controlPointB = this.controlPointB.applyMatrix(matrix);
return new CAL.BezierPoint(position, controlPointA, controlPointB);
};
CAL.BezierPoint.prototype.draw = function (context) {
var leftHandle = this.controlPointA.add(this.position);
var rightHandle = this.controlPointB.add(this.position);
context.strokeStyle = "#09F";
context.beginPath();
context.moveTo(leftHandle.x, leftHandle.y);
context.lineTo(this.position.x, this.position.y);
context.lineTo(rightHandle.x, rightHandle.y);
context.stroke();
context.beginPath();
context.arc(this.position.x, this.position.y, 10, 0, Math.PI*2, true);
context.stroke();
context.beginPath();
context.arc(leftHandle.x, leftHandle.y, 5, 0, Math.PI*2, true);
context.stroke();
context.beginPath();
context.arc(rightHandle.x, rightHandle.y, 5, 0, Math.PI*2, true);
context.stroke();
};
function recursiveBezier (p1, p2, p3, p4, precision) {
//source: http://antigrain.com/research/adaptive_bezier/
//source: http://en.wikipedia.org/wiki/B%C3%A9zier_curve#Derivative
var p12 = p1.add(p2).scale(0.5);
var p23 = p2.add(p3).scale(0.5);
var p34 = p3.add(p4).scale(0.5);
var p123 = p12.add(p23).scale(0.5);
var p234 = p23.add(p34).scale(0.5);
var p1234 = p123.add(p234).scale(0.5);
var d = p4.subtract(p1);
var d2 = Math.abs((p2.x - p4.x) * d.y - (p2.y - p4.y) * d.x);
var d3 = Math.abs((p3.x - p4.x) * d.y - (p3.y - p4.y) * d.x);
//if (Math.abs(p1.x + p3.x - p2.x - p2.x) + Math.abs(p1.y + p3.y - p2.y - p2.y) + Math.abs(p2.x + p4.x - p3.x - p3.x) + Math.abs(p2.y + p4.y - p3.y - p3.y) <= precision) {
if (Math.pow((d2 + d3), 2) < precision * d.dot(d)) {
//var t = 0.5;
//var derivative = (p2.subtract(p1)).scale(Math.pow(3*(1-t), 2)).add((p3.subtract(p2)).scale(6*(1-t)*t)).add((p4.subtract(p3)).scale(Math.pow(3*t, 2)));
var derivative = (p2.subtract(p1)).scale(2.25).add((p3.subtract(p2)).scale(1.5)).add((p4.subtract(p3)).scale(2.25));
var point = {
x: p1234.x,
y: p1234.y,
angle: derivative.direction()
}
return [point];
}
else {
return [].concat(
recursiveBezier(p1, p12, p123, p1234, precision),
recursiveBezier(p1234, p234, p34, p4, precision)
);
}
}*/
CAL.Text = function (options) {
options = options || {};
CAL.Matrix.call(this, options);
this.visible = options.visible !== undefined ? options.visible : true;
this.active = options.active !== undefined ? options.active : true;
this.depth = options.depth || 0;
this.text = options.text || "";
this.style = options.style || "normal";
this.variant = options.variant || "normal";
this.weight = options.weight || "normal";
this.size = options.size || 12;
this.font = options.font || "Arial";
this.textAlign = options.textAlign || "left";
this.color = options.color || new CAL.Color();
this.alpha = typeof options.alpha === "number" ? options.alpha : 1;
};
CAL.Text.prototype = Object.create(CAL.Matrix.prototype);
CAL.Text.prototype.drawText = function (context, text, x, y) {
context.font = [this.style, this.variant, this.weight, this.size+"px", this.font].join(" ");
context.textAlign = this.textAlign;
this.color.setColor(context);
context.fillText(text, x, y);
};
CAL.Text.prototype.drawTextAlpha = function (context, text, x, y, apha) {
context.font = [this.style, this.variant, this.weight, this.size+"px", this.font].join(" ");
context.globalAlpha = apha;
this.color.setColor(context);
context.fillText(text, x, y);
context.globalAlpha = 1;
};
CAL.Text.prototype.draw = function (context, matrix) {
context.save();
matrix.setContext(context);
context.globalAlpha = this.alpha;
this.drawText(context, this.text, 0, 0);
context.restore();
};
CAL.Text.prototype.clone = function () {
return new CAL.text({
style : this.style,
variant : this.variant,
weight : this.weight,
size : this.size,
font : this.font,
color : this.color.clone()
});
};
CAL.KeyListener = function (options) {
options = options || {};
this.visible = false;
this.active = options.active !== undefined ? option.active : true;
this.depth = -10000;
this.actions = options.actions || {};
CAL.Scene.add(this);
};
CAL.KeyListener.prototype.add = function (key, callback) {
this.actions[key] = callback;
};
CAL.KeyListener.prototype.keyDown = function (key) {
if (this.actions[key]) {
this.actions[key]();
}
};
CAL.Physics = function () {
CAL.Scene.add(this);
this.depth = -1000;
this.active = true;
this.visible = false;
this.objects = [];
this.manifolds = [];
this.forces = [];
}
CAL.Physics.prototype.keyDown = function () {
//DEBUG REASONS
//EASIER TO DEBUG ON KEYDOWN
CAL.Scene.clear();
this.test(120);
polygon.debugDraw(CAL.Scene.context);
box.debugDraw(CAL.Scene.context);
};
CAL.Physics.prototype.add = function () {
for (var i = 0; i < arguments.length; i ++) {
var object = arguments[i];
if (object instanceof CAL.PhysicsObject && this.objects.indexOf(object) === -1) {
for (var j = 0; j < this.objects.length; j ++) {
this.manifolds.push(new CAL.Manifold(object, this.objects[j]));
this.manifolds.push(new CAL.Manifold(this.objects[j], object));
}
this.objects.push(object);
}
else if (object instanceof CAL.Force && this.forces.indexOf(object) === -1) {
this.forces.push(object);
}
}
};
CAL.Physics.prototype.test = function (dt) {
//var dt = 120;
this.objects.foreach(function (object) {
object.step(dt);
}, this);
this.forces.foreach(function (force) {
force.step(dt);
}, this);
this.manifolds.foreach(function (manifold) {
manifold.step(dt);
}, this);
};
CAL.Manifold = function (a, b) {
this.a = a;
this.b = b;
this.normal;
};
CAL.Manifold.prototype.checkCollision = function (dt) {
var collisionData = {collision: false};
this.b.shape.points.foreach(function (pointA, i) {
var pointA = pointA.applyMatrix(this.b.shape);
var collision = true;
var bestDistance = -Infinity;
var bestNormal;
this.a.shape.points.foreach(function (pointB, j) {
var pointB = pointB.applyMatrix(this.a.shape);
var normal = this.a.shape.getNormal(j);
var distance = normal.dot(pointA.subtract(pointB));
if (distance > 0) {
collision = false;
return true;
}
else if (distance > bestDistance) {
bestDistance = distance;
bestNormal = normal;
}
}, this);
if (collision) {
collisionData = {collision: true, penetrationDepth: -bestDistance, normal: bestNormal, impactPoint: pointA};
return true;
}
}, this);
return collisionData;
/*this.a.shape.points.foreach(function (point, i) {
var normal = this.a.shape.getNormal(i);
var support = this.b.getSupport(normal.scale(-1));
var point = point.applyMatrix(this.a.shape);
var distance = normal.dot(support.subtract(point));
//if (distance > 0) {
// console.log("test");
// bestDistance = 1;
// return true;
//}
if (distance > bestDistance || bestDistance === false) {
//var velocity = this.b.velocity.add(this.b.getPointVelocity(support));
//if (velocity.dot(normal) < 0 || velocity.length === 0) {
bestDistance = distance;
bestNormal = normal;
bestImpactPoint = support;
//bestVelocity = velocity;
//}
}
}, this);
var i = 2;
var normal = this.a.shape.getNormal(i);
normal.scale(100).draw(CAL.Scene.context, 200, 200);
var support = this.b.getSupport(normal.scale(-1));
var point = this.a.shape.points[i].applyMatrix(this.a.shape);
var distance = normal.dot(support.subtract(point));
console.log(distance);
CAL.Scene.context.beginPath();
CAL.Scene.context.arc(support.x, support.y, 10, 0, Math.PI*2);
CAL.Scene.context.stroke();
return {collision: bestDistance < 0, penetrationDepth: bestDistance, normal: bestNormal, impactPoint: bestImpactPoint};*/
};
CAL.Manifold.prototype.positionalCorrection = function (collisionData) {
var percent = 0.2; // usually 20% to 80%
var slop = 0.1; // usually 0.01 to 0.1
var correction = collisionData.normal.scale(Math.max(collisionData.penetrationDepth - slop, 0) / (1/this.a.mass + 1/this.b.mass) * percent);
var aPos = correction.scale(1/this.a.mass);
this.a.shape._x += aPos.x;
this.a.shape._y += aPos.y;
this.a.shape.updateMatrix();
var bPos = correction.scale(1/this.b.mass);
this.b.shape._x -= bPos.x;
this.b.shape._y -= bPos.y;
this.b.shape.updateMatrix();
};
CAL.Manifold.prototype.resolveCollision = function (collisionData) {
var restVelocity = this.b.velocity.subtract(this.a.velocity);
var velAlongNormal = restVelocity.dot(collisionData.normal);
if (velAlongNormal > 0) {
return;
}
var restitution = Math.min(this.a.restitution, this.b.restitution);
var force = -(1 + restitution) * velAlongNormal / (1/this.a.mass + 1/this.b.mass);
var impulse = collisionData.normal.scale(force);
this.a.addForce(impulse.scale(-1), collisionData.impactPoint);
this.b.addForce(impulse, collisionData.impactPoint);
};
CAL.Manifold.prototype.step = function (dt) {
var collisionData = this.checkCollision();
if (collisionData.collision) {
this.resolveCollision(collisionData);
this.positionalCorrection(collisionData);
}
};
CAL.PhysicsObject = function (options) {
options = options || {};
this.shape = options.shape || new CAL.Shape();
this.velocity = options.velocity || new CAL.Vector();
this.angularVelocity = options.angularVelocity !== undefined ? options.angularVelocity : 0;
this.restitution = options.restitution !== undefined ? options.restitution : 0.5;
this.density = options.density || 1;
this.updateMass();
};
CAL.PhysicsObject.prototype.calculateBoundingBox = function (matrix) {
matrix = matrix || this.shape;
var minX = Infinity;
var minY = Infinity;
var maxX = -Infinity;
var maxY = -Infinity;
this.shape.points.foreach(function (point) {
var point = point.applyMatrix(matrix);
minX = (point.x < minX) ? point.x : minX;
minY = (point.y < minY) ? point.y : minY;
maxX = (point.x > maxX) ? point.x : maxX;
maxY = (point.y > maxY) ? point.y : maxY;
}, this);
return {minX: minX, minY: minY, maxX: maxX, maxY: maxY};
};
CAL.PhysicsObject.prototype.addForce = function (impulse, contactVector) {
this.velocity = this.velocity.add(impulse.scale(1.0/this.mass));
/*if (contactVector !== undefined) {
this.angularVelocity += contactVector.subtract(this.centerOfMass.applyMatrix(this.shape)).cross(impulse)*(1.0/this.inertia);
//this.angularVelocity = contactVector.subtract(this.centerOfMass.applyMatrix(this.shape)).cross(impulse)*(1.0/this.inertia);
}*/
};
CAL.PhysicsObject.prototype.pointCollision = function (point) {
var point = point
.subtract(new CAL.Vector(this.shape.x, this.shape.y))
.rotate(-this.shape.rotation)
.multiply(new CAL.Vector(1/this.shape.sx, 1/this.shape.sy))
.subtract(new CAL.Vector(this.collisionMask.offsetX, this.collisionMask.offsetY));
if (point.x < 0) return false;
if (point.y < 0) return false;
if (point.x > this.collisionMask.width) return false;
if (point.y > this.collisionMask.height) return false;
var i = Math.round(point.y)*this.collisionMask.width + Math.round(point.x);
return this.collisionMask.data[i];
};
CAL.PhysicsObject.prototype.setDensity = function (density) {
this.density = density;
this.mass = this.area*density;
this.inertia = this.mass*this.area;
};
CAL.PhysicsObject.prototype.updateMass = function () {
var boundingBox = this.calculateBoundingBox(new CAL.Matrix());
var surface = new CAL.Surface({x: boundingBox.maxX - boundingBox.minX, y: boundingBox.maxY - boundingBox.minY});
this.shape.clip(surface.context, new CAL.Matrix({x: -boundingBox.minX, y: -boundingBox.minY}));
surface.context.fillStyle = "black";
surface.context.fillRect(0, 0, surface.width, surface.height);
var imageData = surface.getImageData();
var point = new CAL.Vector();
var area = 0;
this.collisionMask = {
data: [],
width: imageData.width,
height: imageData.height,
offsetX: boundingBox.minX,
offsetY: boundingBox.minY
};
for (var i = 0; i < imageData.data.length; i += 4) {
var alpha = imageData.data[i + 3];
if (alpha > 0) {
point = point.add(new CAL.Vector(i/4 % imageData.width, Math.floor(i/4/imageData.width)));
area ++;
this.collisionMask.data.push(true);
}
else {
this.collisionMask.data.push(false);
}
}
this.area = area/**this.sx*this.sy*/;
this.mass = area*this.density;
this.inertia = this.mass*area;
this.centerOfMass = point.scale(1/area).add(new CAL.Vector(boundingBox.minX, boundingBox.minY));
};
CAL.PhysicsObject.prototype.getSupport = function (n) {
var bestProjection = -Infinity;
var bestPoint;
for (var i = 0; i < this.shape.points.length; i ++) {
var point = this.shape.points[i].applyMatrix(this.shape);
var projection = point.dot(n);
if (projection > bestProjection) {
bestPoint = point;
bestProjection = projection;
}
}
return bestPoint;
};
CAL.PhysicsObject.prototype.getPointVelocity = function (point) {
var relativePoint = point.subtract(this.centerOfMass.applyMatrix(this.shape));
var rotatedPoint = relativePoint.rotate(this.angularVelocity);
return rotatedPoint.subtract(relativePoint);
};
CAL.PhysicsObject.prototype.findCollisionFace = function (point) {
};
CAL.PhysicsObject.prototype.step = function (dt) {
//this.rotateAroundRelative(this.torque*dt, this.centerOfMass);
//this.angularVelocity += torque * (1.0 / this.inertia) * dt
/*if (this.velocity.length < 0.0001) {
this.velocity = new CAL.Vector();
}
if (Math.abs(this.angularVelocity) < 0.00001) {
this.angularVelocity = 0;
}*/
this.shape._x += this.velocity.x*dt;
this.shape._y += this.velocity.y*dt;
this.shape.updateMatrix();
//this.shape.rotateAroundRelative(this.angularVelocity*dt, this.centerOfMass);
};
CAL.PhysicsObject.prototype.debugDraw = function (context) {
context.lineWidth = 1;
context.strokeStyle = "black";
var minX = Infinity;
var minY = Infinity;
var maxX = -Infinity;
var maxY = -Infinity;
context.beginPath();
this.shape.points.foreach(function (point) {
var point = point.applyMatrix(this.shape);
context.lineTo(point.x, point.y);
context.arc(point.x, point.y, 3, 0, 2*Math.PI*2);
context.lineTo(point.x, point.y);
minX = (point.x < minX) ? point.x : minX
minY = (point.y < minY) ? point.y : minY
maxX = (point.x > maxX) ? point.x : maxX
maxY = (point.y > maxY) ? point.y : maxY
}, this);
context.closePath();
context.stroke();
this.shape.points.foreach(function (point, i) {
var point = point.applyMatrix(this.shape);
var text = new CAL.Text();
text.drawText(context, i, point.x + 10, point.y - 10);
//this.getPointVelocity(point).scale(1000).draw(context, point.x, point.y);
}, this);
context.beginPath();
context.moveTo(minX, minY);
context.lineTo(minX, maxY);
context.lineTo(maxX, maxY);
context.lineTo(maxX, minY);
context.closePath();
var centerOfMass = this.centerOfMass.applyMatrix(this.shape);
context.moveTo(centerOfMass.x-5, centerOfMass.y-5);
context.lineTo(centerOfMass.x+5, centerOfMass.y+5);
context.moveTo(centerOfMass.x+5, centerOfMass.y-5);
context.lineTo(centerOfMass.x-5, centerOfMass.y+5);
context.strokeStyle = "red";
context.stroke();
var center = this.centerOfMass.applyMatrix(this.shape);
this.velocity.scale(1000).draw(context, center.x, center.y);
};
CAL.Force = function (options) {
this.objects = options.objects || [];
this.velocity = options.velocity || new CAL.Vector();
}
CAL.Force.prototype.add = function () {
for (var i = 0; i < arguments.length; i ++) {
var argument = arguments[i];
this.objects.push(argument);
}
};
CAL.Force.prototype.step = function (dt) {
for (var i = 0; i < this.objects.length; i ++) {
var object = this.objects[i];
object.velocity = object.velocity.add(this.velocity.scale(dt));
}
};