%PDF-
%PDF-
Mini Shell
Mini Shell
/**
* Bounce.js 0.8.2
* MIT license
*/
!function(e){if("object"==typeof exports)module.exports=e();else if("function"==typeof define&&define.amd)define(e);else{var f;"undefined"!=typeof window?f=window:"undefined"!=typeof global?f=global:"undefined"!=typeof self&&(f=self),f.Bounce=e()}}(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);throw new Error("Cannot find module '"+o+"'")}var f=n[o]={exports:{}};t[o][0].call(f.exports,function(e){var n=t[o][1][e];return s(n?n:e)},f,f.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(_dereq_,module,exports){
var Component, EasingClasses, Matrix4D;
Matrix4D = _dereq_("../math/matrix4d");
EasingClasses = {
bounce: _dereq_("../easing/bounce"),
sway: _dereq_("../easing/sway"),
hardbounce: _dereq_("../easing/hardbounce"),
hardsway: _dereq_("../easing/hardsway")
};
Component = (function() {
Component.prototype.easing = "bounce";
Component.prototype.duration = 1000;
Component.prototype.delay = 0;
Component.prototype.from = null;
Component.prototype.to = null;
function Component(options) {
options || (options = {});
if (options.easing != null) {
this.easing = options.easing;
}
if (options.duration != null) {
this.duration = options.duration;
}
if (options.delay != null) {
this.delay = options.delay;
}
if (options.from != null) {
this.from = options.from;
}
if (options.to != null) {
this.to = options.to;
}
this.easingObject = new EasingClasses[this.easing](options);
}
Component.prototype.calculateEase = function(ratio) {
return this.easingObject.calculate(ratio);
};
Component.prototype.getMatrix = function() {
return new Matrix4D().identity();
};
Component.prototype.getEasedMatrix = function(ratio) {
return this.getMatrix();
};
Component.prototype.serialize = function() {
var key, serialized, value, _ref;
serialized = {
type: this.constructor.name.toLowerCase(),
easing: this.easing,
duration: this.duration,
delay: this.delay,
from: this.from,
to: this.to
};
_ref = this.easingObject.serialize();
for (key in _ref) {
value = _ref[key];
serialized[key] = value;
}
return serialized;
};
return Component;
})();
module.exports = Component;
},{"../easing/bounce":6,"../easing/hardbounce":7,"../easing/hardsway":8,"../easing/sway":10,"../math/matrix4d":13}],2:[function(_dereq_,module,exports){
var Component, Matrix4D, Rotate, Vector2D,
__hasProp = {}.hasOwnProperty,
__extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };
Matrix4D = _dereq_("../math/matrix4d");
Vector2D = _dereq_("../math/vector2d");
Component = _dereq_("./index");
Rotate = (function(_super) {
__extends(Rotate, _super);
Rotate.prototype.from = 0;
Rotate.prototype.to = 90;
function Rotate() {
Rotate.__super__.constructor.apply(this, arguments);
this.diff = this.to - this.from;
}
Rotate.prototype.getMatrix = function(degrees) {
var c, radians, s;
radians = (degrees / 180) * Math.PI;
c = Math.cos(radians);
s = Math.sin(radians);
return new Matrix4D([c, -s, 0, 0, s, c, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]);
};
Rotate.prototype.getEasedMatrix = function(ratio) {
var easedAngle, easedRatio;
easedRatio = this.calculateEase(ratio);
easedAngle = this.from + this.diff * easedRatio;
return this.getMatrix(easedAngle);
};
return Rotate;
})(Component);
module.exports = Rotate;
},{"../math/matrix4d":13,"../math/vector2d":14,"./index":1}],3:[function(_dereq_,module,exports){
var Component, Matrix4D, Scale, Vector2D,
__hasProp = {}.hasOwnProperty,
__extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };
Matrix4D = _dereq_("../math/matrix4d");
Vector2D = _dereq_("../math/vector2d");
Component = _dereq_("./index");
Scale = (function(_super) {
__extends(Scale, _super);
Scale.prototype.from = {
x: 0.5,
y: 0.5
};
Scale.prototype.to = {
x: 1,
y: 1
};
function Scale() {
Scale.__super__.constructor.apply(this, arguments);
this.fromVector = new Vector2D(this.from.x, this.from.y);
this.toVector = new Vector2D(this.to.x, this.to.y);
this.diff = this.toVector.clone().subtract(this.fromVector);
}
Scale.prototype.getMatrix = function(x, y) {
var z;
z = 1;
return new Matrix4D([x, 0, 0, 0, 0, y, 0, 0, 0, 0, z, 0, 0, 0, 0, 1]);
};
Scale.prototype.getEasedMatrix = function(ratio) {
var easedRatio, easedVector;
easedRatio = this.calculateEase(ratio);
easedVector = this.fromVector.clone().add(this.diff.clone().multiply(easedRatio));
return this.getMatrix(easedVector.x, easedVector.y);
};
return Scale;
})(Component);
module.exports = Scale;
},{"../math/matrix4d":13,"../math/vector2d":14,"./index":1}],4:[function(_dereq_,module,exports){
var Component, Matrix4D, Skew, Vector2D,
__hasProp = {}.hasOwnProperty,
__extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };
Matrix4D = _dereq_("../math/matrix4d");
Vector2D = _dereq_("../math/vector2d");
Component = _dereq_("./index");
Skew = (function(_super) {
__extends(Skew, _super);
Skew.prototype.from = {
x: 0,
y: 0
};
Skew.prototype.to = {
x: 20,
y: 0
};
function Skew() {
Skew.__super__.constructor.apply(this, arguments);
this.fromVector = new Vector2D(this.from.x, this.from.y);
this.toVector = new Vector2D(this.to.x, this.to.y);
this.diff = this.toVector.clone().subtract(this.fromVector);
}
Skew.prototype.getMatrix = function(degreesX, degreesY) {
var radiansX, radiansY, tx, ty;
radiansX = (degreesX / 180) * Math.PI;
radiansY = (degreesY / 180) * Math.PI;
tx = Math.tan(radiansX);
ty = Math.tan(radiansY);
return new Matrix4D([1, tx, 0, 0, ty, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]);
};
Skew.prototype.getEasedMatrix = function(ratio) {
var easedRatio, easedVector;
easedRatio = this.calculateEase(ratio);
easedVector = this.fromVector.clone().add(this.diff.clone().multiply(easedRatio));
return this.getMatrix(easedVector.x, easedVector.y);
};
return Skew;
})(Component);
module.exports = Skew;
},{"../math/matrix4d":13,"../math/vector2d":14,"./index":1}],5:[function(_dereq_,module,exports){
var Component, Matrix4D, Translate, Vector2D,
__hasProp = {}.hasOwnProperty,
__extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };
Matrix4D = _dereq_("../math/matrix4d");
Vector2D = _dereq_("../math/vector2d");
Component = _dereq_("./index");
Translate = (function(_super) {
__extends(Translate, _super);
Translate.prototype.from = {
x: 0,
y: 0
};
Translate.prototype.to = {
x: 0,
y: 0
};
function Translate() {
Translate.__super__.constructor.apply(this, arguments);
this.fromVector = new Vector2D(this.from.x, this.from.y);
this.toVector = new Vector2D(this.to.x, this.to.y);
this.diff = this.toVector.clone().subtract(this.fromVector);
}
Translate.prototype.getMatrix = function(x, y) {
var z;
z = 0;
return new Matrix4D([1, 0, 0, x, 0, 1, 0, y, 0, 0, 1, z, 0, 0, 0, 1]);
};
Translate.prototype.getEasedMatrix = function(ratio) {
var easedRatio, easedVector;
easedRatio = this.calculateEase(ratio);
easedVector = this.fromVector.clone().add(this.diff.clone().multiply(easedRatio));
return this.getMatrix(easedVector.x, easedVector.y);
};
return Translate;
})(Component);
module.exports = Translate;
},{"../math/matrix4d":13,"../math/vector2d":14,"./index":1}],6:[function(_dereq_,module,exports){
var BounceEasing, Easing,
__hasProp = {}.hasOwnProperty,
__extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };
Easing = _dereq_("./index");
BounceEasing = (function(_super) {
__extends(BounceEasing, _super);
BounceEasing.prototype.bounces = 4;
BounceEasing.prototype.stiffness = 3;
function BounceEasing(options) {
var threshold;
if (options == null) {
options = {};
}
BounceEasing.__super__.constructor.apply(this, arguments);
if (options.stiffness != null) {
this.stiffness = options.stiffness;
}
if (options.bounces != null) {
this.bounces = options.bounces;
}
this.alpha = this.stiffness / 100;
threshold = 0.005 / Math.pow(10, this.stiffness);
this.limit = Math.floor(Math.log(threshold) / -this.alpha);
this.omega = this.calculateOmega(this.bounces, this.limit);
}
BounceEasing.prototype.calculate = function(ratio) {
var t;
if (ratio >= 1) {
return 1;
}
t = ratio * this.limit;
return 1 - this.exponent(t) * this.oscillation(t);
};
BounceEasing.prototype.calculateOmega = function(bounces, limit) {
return (this.bounces + 0.5) * Math.PI / this.limit;
};
BounceEasing.prototype.exponent = function(t) {
return Math.pow(Math.E, -this.alpha * t);
};
BounceEasing.prototype.oscillation = function(t) {
return Math.cos(this.omega * t);
};
BounceEasing.prototype.serialize = function() {
return {
stiffness: this.stiffness,
bounces: this.bounces
};
};
return BounceEasing;
})(Easing);
module.exports = BounceEasing;
},{"./index":9}],7:[function(_dereq_,module,exports){
var BounceEasing, HardBounceEasing,
__hasProp = {}.hasOwnProperty,
__extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };
BounceEasing = _dereq_("./bounce");
HardBounceEasing = (function(_super) {
__extends(HardBounceEasing, _super);
function HardBounceEasing() {
return HardBounceEasing.__super__.constructor.apply(this, arguments);
}
HardBounceEasing.prototype.oscillation = function(t) {
return Math.abs(Math.cos(this.omega * t));
};
return HardBounceEasing;
})(BounceEasing);
module.exports = HardBounceEasing;
},{"./bounce":6}],8:[function(_dereq_,module,exports){
var HardSwayEasing, SwayEasing,
__hasProp = {}.hasOwnProperty,
__extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };
SwayEasing = _dereq_("./sway");
HardSwayEasing = (function(_super) {
__extends(HardSwayEasing, _super);
function HardSwayEasing() {
return HardSwayEasing.__super__.constructor.apply(this, arguments);
}
HardSwayEasing.prototype.oscillation = function(t) {
return Math.abs(Math.sin(this.omega * t));
};
return HardSwayEasing;
})(SwayEasing);
module.exports = HardSwayEasing;
},{"./sway":10}],9:[function(_dereq_,module,exports){
var Easing, MathHelpers;
MathHelpers = _dereq_("../math/helpers");
Easing = (function() {
function Easing() {}
Easing.prototype.calculate = function(ratio) {
return ratio;
};
Easing.prototype.serialize = function() {
return {};
};
Easing.prototype.findOptimalKeyPoints = function(threshold, resolution) {
var area, halfway, i, keyPoint, keyPoints, loops, result, values;
if (threshold == null) {
threshold = 1.0;
}
if (resolution == null) {
resolution = 1000;
}
keyPoints = [0];
values = (function() {
var _i, _results;
_results = [];
for (i = _i = 0; 0 <= resolution ? _i < resolution : _i > resolution; i = 0 <= resolution ? ++_i : --_i) {
_results.push(this.calculate(i / resolution));
}
return _results;
}).call(this);
keyPoints = keyPoints.concat(MathHelpers.findTurningPoints(values));
keyPoints.push(resolution - 1);
i = 0;
loops = 1000;
while (loops--) {
if (i === keyPoints.length - 1) {
break;
}
area = MathHelpers.areaBetweenLineAndCurve(values, keyPoints[i], keyPoints[i + 1]);
if (area <= threshold) {
i++;
} else {
halfway = Math.round(keyPoints[i] + (keyPoints[i + 1] - keyPoints[i]) / 2);
keyPoints.splice(i + 1, 0, halfway);
}
}
if (loops === 0) {
return [];
}
return result = (function() {
var _i, _len, _results;
_results = [];
for (_i = 0, _len = keyPoints.length; _i < _len; _i++) {
keyPoint = keyPoints[_i];
_results.push(keyPoint / (resolution - 1));
}
return _results;
})();
};
return Easing;
})();
module.exports = Easing;
},{"../math/helpers":12}],10:[function(_dereq_,module,exports){
var BounceEasing, SwayEasing,
__hasProp = {}.hasOwnProperty,
__extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };
BounceEasing = _dereq_("./bounce");
SwayEasing = (function(_super) {
__extends(SwayEasing, _super);
function SwayEasing() {
return SwayEasing.__super__.constructor.apply(this, arguments);
}
SwayEasing.prototype.calculate = function(ratio) {
var t;
if (ratio >= 1) {
return 0;
}
t = ratio * this.limit;
return this.exponent(t) * this.oscillation(t);
};
SwayEasing.prototype.calculateOmega = function(bounces, limit) {
return this.bounces * Math.PI / this.limit;
};
SwayEasing.prototype.oscillation = function(t) {
return Math.sin(this.omega * t);
};
return SwayEasing;
})(BounceEasing);
module.exports = SwayEasing;
},{"./bounce":6}],11:[function(_dereq_,module,exports){
var Bounce, ComponentClasses, Matrix4D;
Matrix4D = _dereq_("./math/matrix4d");
ComponentClasses = {
scale: _dereq_("./components/scale"),
rotate: _dereq_("./components/rotate"),
translate: _dereq_("./components/translate"),
skew: _dereq_("./components/skew")
};
Bounce = (function() {
Bounce.FPS = 30;
Bounce.counter = 1;
Bounce.prototype.components = null;
Bounce.prototype.duration = 0;
function Bounce() {
this.components = [];
}
Bounce.prototype.scale = function(options) {
return this.addComponent(new ComponentClasses["scale"](options));
};
Bounce.prototype.rotate = function(options) {
return this.addComponent(new ComponentClasses["rotate"](options));
};
Bounce.prototype.translate = function(options) {
return this.addComponent(new ComponentClasses["translate"](options));
};
Bounce.prototype.skew = function(options) {
return this.addComponent(new ComponentClasses["skew"](options));
};
Bounce.prototype.addComponent = function(component) {
this.components.push(component);
this.updateDuration();
return this;
};
Bounce.prototype.serialize = function() {
var component, serialized, _i, _len, _ref;
serialized = [];
_ref = this.components;
for (_i = 0, _len = _ref.length; _i < _len; _i++) {
component = _ref[_i];
serialized.push(component.serialize());
}
return serialized;
};
Bounce.prototype.deserialize = function(serialized) {
var options, _i, _len;
for (_i = 0, _len = serialized.length; _i < _len; _i++) {
options = serialized[_i];
this.addComponent(new ComponentClasses[options.type](options));
}
return this;
};
Bounce.prototype.updateDuration = function() {
return this.duration = this.components.map(function(component) {
return component.duration + component.delay;
}).reduce(function(a, b) {
return Math.max(a, b);
});
};
Bounce.prototype.define = function(name) {
this.name = name || Bounce.generateName();
this.styleElement = document.createElement("style");
this.styleElement.innerHTML = this.getKeyframeCSS({
name: this.name,
prefix: true
});
document.body.appendChild(this.styleElement);
return this;
};
Bounce.prototype.applyTo = function(elements, options) {
var css, deferred, element, prefix, prefixes, _i, _j, _len, _len1, _ref;
if (options == null) {
options = {};
}
this.define();
if (!elements.length) {
elements = [elements];
}
prefixes = this.getPrefixes();
deferred = null;
if (window.jQuery && window.jQuery.Deferred) {
deferred = new window.jQuery.Deferred();
}
for (_i = 0, _len = elements.length; _i < _len; _i++) {
element = elements[_i];
_ref = prefixes.animation;
for (_j = 0, _len1 = _ref.length; _j < _len1; _j++) {
prefix = _ref[_j];
css = [this.name, "" + this.duration + "ms", "linear", "both"];
if (options.loop) {
css.push("infinite");
}
element.style["" + prefix + "animation"] = css.join(" ");
}
}
if (!options.loop) {
setTimeout(((function(_this) {
return function() {
if (options.remove) {
_this.remove();
}
if (typeof options.onComplete === "function") {
options.onComplete();
}
if (deferred) {
return deferred.resolve();
}
};
})(this)), this.duration);
}
return deferred;
};
Bounce.prototype.remove = function() {
var _ref;
if (!this.styleElement) {
return;
}
if (this.styleElement.remove) {
return this.styleElement.remove();
} else {
return (_ref = this.styleElement.parentNode) != null ? _ref.removeChild(this.styleElement) : void 0;
}
};
Bounce.prototype.getPrefixes = function(force) {
var prefixes, style;
prefixes = {
transform: [""],
animation: [""]
};
style = document.createElement("dummy").style;
if (force || (!("transform" in style) && "webkitTransform" in style)) {
prefixes.transform = ["-webkit-", ""];
}
if (force || (!("animation" in style) && "webkitAnimation" in style)) {
prefixes.animation = ["-webkit-", ""];
}
return prefixes;
};
Bounce.prototype.getKeyframeCSS = function(options) {
var animations, key, keyframeList, keyframes, matrix, prefix, prefixes, transformString, transforms, _i, _j, _k, _len, _len1, _len2, _ref, _ref1, _ref2;
if (options == null) {
options = {};
}
this.name = options.name || Bounce.generateName();
prefixes = {
transform: [""],
animation: [""]
};
if (options.prefix || options.forcePrefix) {
prefixes = this.getPrefixes(options.forcePrefix);
}
keyframeList = [];
keyframes = this.getKeyframes(options);
_ref = this.keys;
for (_i = 0, _len = _ref.length; _i < _len; _i++) {
key = _ref[_i];
matrix = keyframes[key];
transformString = "matrix3d" + matrix;
transforms = [];
_ref1 = prefixes.transform;
for (_j = 0, _len1 = _ref1.length; _j < _len1; _j++) {
prefix = _ref1[_j];
transforms.push("" + prefix + "transform: " + transformString + ";");
}
keyframeList.push("" + (Math.round(key * 100 * 100) / 100) + "% { " + (transforms.join(" ")) + " }");
}
animations = [];
_ref2 = prefixes.animation;
for (_k = 0, _len2 = _ref2.length; _k < _len2; _k++) {
prefix = _ref2[_k];
animations.push("@" + prefix + "keyframes " + this.name + " { \n " + (keyframeList.join("\n ")) + " \n}");
}
return animations.join("\n\n");
};
Bounce.prototype.getKeyframes = function(options) {
var component, componentKeys, currentTime, frames, i, key, keyframes, keys, matrix, ratio, _i, _j, _k, _l, _len, _len1, _len2, _ref, _ref1;
if (options == null) {
options = {};
}
keys = [0, 1];
if (options.optimized) {
_ref = this.components;
for (_i = 0, _len = _ref.length; _i < _len; _i++) {
component = _ref[_i];
componentKeys = component.easingObject.findOptimalKeyPoints().map((function(_this) {
return function(key) {
return (key * component.duration / _this.duration) + (component.delay / _this.duration);
};
})(this));
if (component.delay) {
componentKeys.push((component.delay / this.duration) - 0.001);
}
keys = keys.concat(componentKeys);
}
} else {
frames = Math.round((this.duration / 1000) * Bounce.FPS);
for (i = _j = 0; 0 <= frames ? _j <= frames : _j >= frames; i = 0 <= frames ? ++_j : --_j) {
keys.push(i / frames);
}
}
keys = keys.sort(function(a, b) {
return a - b;
});
this.keys = [];
keyframes = {};
for (_k = 0, _len1 = keys.length; _k < _len1; _k++) {
key = keys[_k];
if (keyframes[key]) {
continue;
}
matrix = new Matrix4D().identity();
_ref1 = this.components;
for (_l = 0, _len2 = _ref1.length; _l < _len2; _l++) {
component = _ref1[_l];
currentTime = key * this.duration;
if ((component.delay - currentTime) > 1e-8) {
continue;
}
ratio = (key - component.delay / this.duration) / (component.duration / this.duration);
matrix.multiply(component.getEasedMatrix(ratio));
}
this.keys.push(key);
keyframes[key] = matrix.transpose().toFixed(3);
}
return keyframes;
};
Bounce.generateName = function() {
return "animation-" + (Bounce.counter++);
};
Bounce.isSupported = function() {
var property, propertyIsSupported, propertyList, propertyLists, style, _i, _j, _len, _len1;
style = document.createElement("dummy").style;
propertyLists = [["transform", "webkitTransform"], ["animation", "webkitAnimation"]];
for (_i = 0, _len = propertyLists.length; _i < _len; _i++) {
propertyList = propertyLists[_i];
propertyIsSupported = false;
for (_j = 0, _len1 = propertyList.length; _j < _len1; _j++) {
property = propertyList[_j];
propertyIsSupported || (propertyIsSupported = property in style);
}
if (!propertyIsSupported) {
return false;
}
}
return true;
};
return Bounce;
})();
module.exports = Bounce;
},{"./components/rotate":2,"./components/scale":3,"./components/skew":4,"./components/translate":5,"./math/matrix4d":13}],12:[function(_dereq_,module,exports){
var MathHelpers;
MathHelpers = (function() {
function MathHelpers() {}
MathHelpers.prototype.sign = function(value) {
if (value < 0) {
return -1;
}
return 1;
};
MathHelpers.prototype.findTurningPoints = function(values) {
var i, signA, signB, turningPoints, _i, _ref;
turningPoints = [];
for (i = _i = 1, _ref = values.length - 1; 1 <= _ref ? _i < _ref : _i > _ref; i = 1 <= _ref ? ++_i : --_i) {
signA = this.sign(values[i] - values[i - 1]);
signB = this.sign(values[i + 1] - values[i]);
if (signA !== signB) {
turningPoints.push(i);
}
}
return turningPoints;
};
MathHelpers.prototype.areaBetweenLineAndCurve = function(values, start, end) {
var area, curveValue, i, length, lineValue, yEnd, yStart, _i;
length = end - start;
yStart = values[start];
yEnd = values[end];
area = 0;
for (i = _i = 0; 0 <= length ? _i <= length : _i >= length; i = 0 <= length ? ++_i : --_i) {
curveValue = values[start + i];
lineValue = yStart + (i / length) * (yEnd - yStart);
area += Math.abs(lineValue - curveValue);
}
return area;
};
return MathHelpers;
})();
module.exports = new MathHelpers;
},{}],13:[function(_dereq_,module,exports){
var Matrix4D;
Matrix4D = (function() {
Matrix4D.prototype._array = null;
function Matrix4D(array) {
this._array = (array != null ? array.slice(0) : void 0) || [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
}
Matrix4D.prototype.equals = function(matrix) {
return this.toString() === matrix.toString();
};
Matrix4D.prototype.identity = function() {
this.setArray([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]);
return this;
};
Matrix4D.prototype.multiply = function(matrix) {
var i, j, k, res, value, _i, _j, _k;
res = new Matrix4D;
for (i = _i = 0; _i < 4; i = ++_i) {
for (j = _j = 0; _j < 4; j = ++_j) {
for (k = _k = 0; _k < 4; k = ++_k) {
value = res.get(i, j) + this.get(i, k) * matrix.get(k, j);
res.set(i, j, value);
}
}
}
return this.copy(res);
};
Matrix4D.prototype.transpose = function() {
var a;
a = this.getArray();
this.setArray([a[0], a[4], a[8], a[12], a[1], a[5], a[9], a[13], a[2], a[6], a[10], a[14], a[3], a[7], a[11], a[15]]);
return this;
};
Matrix4D.prototype.get = function(row, column) {
return this.getArray()[row * 4 + column];
};
Matrix4D.prototype.set = function(row, column, value) {
return this._array[row * 4 + column] = value;
};
Matrix4D.prototype.copy = function(matrix) {
this._array = matrix.getArray();
return this;
};
Matrix4D.prototype.clone = function() {
return new Matrix4D(this.getArray());
};
Matrix4D.prototype.getArray = function() {
return this._array.slice(0);
};
Matrix4D.prototype.setArray = function(array) {
this._array = array;
return this;
};
Matrix4D.prototype.toString = function() {
return "(" + (this.getArray().join(", ")) + ")";
};
Matrix4D.prototype.toFixed = function(n) {
var value;
this._array = (function() {
var _i, _len, _ref, _results;
_ref = this._array;
_results = [];
for (_i = 0, _len = _ref.length; _i < _len; _i++) {
value = _ref[_i];
_results.push(parseFloat(value.toFixed(n)));
}
return _results;
}).call(this);
return this;
};
return Matrix4D;
})();
module.exports = Matrix4D;
},{}],14:[function(_dereq_,module,exports){
var Vector2D;
Vector2D = (function() {
Vector2D.prototype.x = 0;
Vector2D.prototype.y = 0;
function Vector2D(x, y) {
this.x = x != null ? x : 0;
this.y = y != null ? y : 0;
}
Vector2D.prototype.add = function(vector) {
if (!Vector2D.isVector2D(vector)) {
return this._addScalar(vector);
}
this.x += vector.x;
this.y += vector.y;
return this;
};
Vector2D.prototype._addScalar = function(n) {
this.x += n;
this.y += n;
return this;
};
Vector2D.prototype.subtract = function(vector) {
if (!Vector2D.isVector2D(vector)) {
return this._subtractScalar(vector);
}
this.x -= vector.x;
this.y -= vector.y;
return this;
};
Vector2D.prototype._subtractScalar = function(n) {
return this._addScalar(-n);
};
Vector2D.prototype.multiply = function(vector) {
if (!Vector2D.isVector2D(vector)) {
return this._multiplyScalar(vector);
}
this.x *= vector.x;
this.y *= vector.y;
return this;
};
Vector2D.prototype._multiplyScalar = function(n) {
this.x *= n;
this.y *= n;
return this;
};
Vector2D.prototype.divide = function(vector) {
if (!Vector2D.isVector2D(vector)) {
return this._divideScalar(vector);
}
this.x /= vector.x;
this.y /= vector.y;
return this;
};
Vector2D.prototype._divideScalar = function(n) {
return this._multiplyScalar(1 / n);
};
Vector2D.prototype.clone = function() {
return new Vector2D(this.x, this.y);
};
Vector2D.prototype.copy = function(vector) {
this.x = vector.x;
this.y = vector.y;
return this;
};
Vector2D.prototype.equals = function(vector) {
return vector.x === this.x && vector.y === this.y;
};
Vector2D.prototype.toString = function() {
return "(" + this.x + ", " + this.y + ")";
};
Vector2D.prototype.toFixed = function(n) {
this.x = parseFloat(this.x.toFixed(n));
this.y = parseFloat(this.y.toFixed(n));
return this;
};
Vector2D.prototype.toArray = function() {
return [this.x, this.y];
};
Vector2D.isVector2D = function(item) {
return item instanceof Vector2D;
};
return Vector2D;
})();
module.exports = Vector2D;
},{}]},{},[11])
(11)
});
Zerion Mini Shell 1.0