3801 lines
92 KiB
Java
3801 lines
92 KiB
Java
(function webpackUniversalModuleDefinition(root, factory) {
|
||
if(typeof exports === 'object' && typeof module === 'object')
|
||
module.exports = factory();
|
||
else if(typeof define === 'function' && define.amd)
|
||
define([], factory);
|
||
else if(typeof exports === 'object')
|
||
exports["coord"] = factory();
|
||
else
|
||
root["coord"] = factory();
|
||
})(typeof self !== 'undefined' ? self : this, function() {
|
||
return /******/ (function(modules) { // webpackBootstrap
|
||
/******/ // The module cache
|
||
/******/ var installedModules = {};
|
||
/******/
|
||
/******/ // The require function
|
||
/******/ function __webpack_require__(moduleId) {
|
||
/******/
|
||
/******/ // Check if module is in cache
|
||
/******/ if(installedModules[moduleId]) {
|
||
/******/ return installedModules[moduleId].exports;
|
||
/******/ }
|
||
/******/ // Create a new module (and put it into the cache)
|
||
/******/ var module = installedModules[moduleId] = {
|
||
/******/ i: moduleId,
|
||
/******/ l: false,
|
||
/******/ exports: {}
|
||
/******/ };
|
||
/******/
|
||
/******/ // Execute the module function
|
||
/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
|
||
/******/
|
||
/******/ // Flag the module as loaded
|
||
/******/ module.l = true;
|
||
/******/
|
||
/******/ // Return the exports of the module
|
||
/******/ return module.exports;
|
||
/******/ }
|
||
/******/
|
||
/******/
|
||
/******/ // expose the modules object (__webpack_modules__)
|
||
/******/ __webpack_require__.m = modules;
|
||
/******/
|
||
/******/ // expose the module cache
|
||
/******/ __webpack_require__.c = installedModules;
|
||
/******/
|
||
/******/ // define getter function for harmony exports
|
||
/******/ __webpack_require__.d = function(exports, name, getter) {
|
||
/******/ if(!__webpack_require__.o(exports, name)) {
|
||
/******/ Object.defineProperty(exports, name, {
|
||
/******/ configurable: false,
|
||
/******/ enumerable: true,
|
||
/******/ get: getter
|
||
/******/ });
|
||
/******/ }
|
||
/******/ };
|
||
/******/
|
||
/******/ // getDefaultExport function for compatibility with non-harmony modules
|
||
/******/ __webpack_require__.n = function(module) {
|
||
/******/ var getter = module && module.__esModule ?
|
||
/******/ function getDefault() { return module['default']; } :
|
||
/******/ function getModuleExports() { return module; };
|
||
/******/ __webpack_require__.d(getter, 'a', getter);
|
||
/******/ return getter;
|
||
/******/ };
|
||
/******/
|
||
/******/ // Object.prototype.hasOwnProperty.call
|
||
/******/ __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
|
||
/******/
|
||
/******/ // __webpack_public_path__
|
||
/******/ __webpack_require__.p = "";
|
||
/******/
|
||
/******/ // Load entry module and return exports
|
||
/******/ return __webpack_require__(__webpack_require__.s = 7);
|
||
/******/ })
|
||
/************************************************************************/
|
||
/******/ ([
|
||
/* 0 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a 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); } }
|
||
|
||
function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
|
||
|
||
/**
|
||
* @fileOverview the base class of Coordinate
|
||
* @author sima.zhang
|
||
*/
|
||
var MatrixUtil = __webpack_require__(2);
|
||
|
||
var mix = __webpack_require__(1);
|
||
|
||
var mat3 = MatrixUtil.mat3;
|
||
var vec3 = MatrixUtil.vec3;
|
||
|
||
var Coord =
|
||
/*#__PURE__*/
|
||
function () {
|
||
_createClass(Coord, [{
|
||
key: "getDefaultCfg",
|
||
|
||
/**
|
||
* 获取默认的配置属性
|
||
* @protected
|
||
* @return {Object} 默认属性
|
||
*/
|
||
value: function getDefaultCfg() {
|
||
return {
|
||
/**
|
||
* Mark x y is transposed.
|
||
* @type {Boolean}
|
||
*/
|
||
isTransposed: false,
|
||
|
||
/**
|
||
* The matrix of coordinate
|
||
* @type {Array}
|
||
*/
|
||
matrix: [1, 0, 0, 0, 1, 0, 0, 0, 1]
|
||
};
|
||
}
|
||
}]);
|
||
|
||
function Coord(cfg) {
|
||
_classCallCheck(this, Coord);
|
||
|
||
var defaultCfg = this.getDefaultCfg();
|
||
mix(this, defaultCfg, cfg);
|
||
this.init();
|
||
}
|
||
|
||
_createClass(Coord, [{
|
||
key: "init",
|
||
value: function init() {
|
||
var start = this.start;
|
||
var end = this.end;
|
||
var center = {
|
||
x: (start.x + end.x) / 2,
|
||
y: (start.y + end.y) / 2
|
||
};
|
||
this.center = center;
|
||
this.width = Math.abs(end.x - start.x);
|
||
this.height = Math.abs(end.y - start.y);
|
||
}
|
||
}, {
|
||
key: "_swapDim",
|
||
value: function _swapDim(dim) {
|
||
var dimRange = this[dim];
|
||
|
||
if (dimRange) {
|
||
var tmp = dimRange.start;
|
||
dimRange.start = dimRange.end;
|
||
dimRange.end = tmp;
|
||
}
|
||
}
|
||
}, {
|
||
key: "getCenter",
|
||
value: function getCenter() {
|
||
return this.center;
|
||
}
|
||
}, {
|
||
key: "getWidth",
|
||
value: function getWidth() {
|
||
return this.width;
|
||
}
|
||
}, {
|
||
key: "getHeight",
|
||
value: function getHeight() {
|
||
return this.height;
|
||
}
|
||
}, {
|
||
key: "convertDim",
|
||
value: function convertDim(percent, dim) {
|
||
var _this$dim = this[dim],
|
||
start = _this$dim.start,
|
||
end = _this$dim.end;
|
||
return start + percent * (end - start);
|
||
}
|
||
}, {
|
||
key: "invertDim",
|
||
value: function invertDim(value, dim) {
|
||
var _this$dim2 = this[dim],
|
||
start = _this$dim2.start,
|
||
end = _this$dim2.end;
|
||
return (value - start) / (end - start);
|
||
}
|
||
/**
|
||
* 将归一化的坐标点数据转换为画布坐标
|
||
* @override
|
||
* @param {Object} point 归一化的坐标点
|
||
* @return {Object} 返回画布坐标
|
||
*/
|
||
|
||
}, {
|
||
key: "convertPoint",
|
||
value: function convertPoint(point) {
|
||
return point;
|
||
}
|
||
/**
|
||
* 将画布坐标转换为归一化的坐标点数据
|
||
* @override
|
||
* @param {Object} point 画布坐标点数据
|
||
* @return {Object} 归一化后的数据点
|
||
*/
|
||
|
||
}, {
|
||
key: "invertPoint",
|
||
value: function invertPoint(point) {
|
||
return point;
|
||
}
|
||
/**
|
||
* 将坐标点进行矩阵变换
|
||
* @param {Number} x 对应 x 轴画布坐标
|
||
* @param {Number} y 对应 y 轴画布坐标
|
||
* @param {Number} tag 默认为 0，可取值 0, 1
|
||
* @return {Array} 返回变换后的三阶向量 [x, y, z]
|
||
*/
|
||
|
||
}, {
|
||
key: "applyMatrix",
|
||
value: function applyMatrix(x, y) {
|
||
var tag = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
|
||
var matrix = this.matrix;
|
||
var vector = [x, y, tag];
|
||
vec3.transformMat3(vector, vector, matrix);
|
||
return vector;
|
||
}
|
||
/**
|
||
* 将坐标点进行矩阵逆变换
|
||
* @param {Number} x 对应 x 轴画布坐标
|
||
* @param {Number} y 对应 y 轴画布坐标
|
||
* @param {Number} tag 默认为 0，可取值 0, 1
|
||
* @return {Array} 返回矩阵逆变换后的三阶向量 [x, y, z]
|
||
*/
|
||
|
||
}, {
|
||
key: "invertMatrix",
|
||
value: function invertMatrix(x, y) {
|
||
var tag = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
|
||
var matrix = this.matrix;
|
||
var inversedMatrix = mat3.invert([], matrix);
|
||
var vector = [x, y, tag];
|
||
vec3.transformMat3(vector, vector, inversedMatrix);
|
||
return vector;
|
||
}
|
||
/**
|
||
* 将归一化的坐标点数据转换为画布坐标，并根据坐标系当前矩阵进行变换
|
||
* @param {Object} point 归一化的坐标点
|
||
* @return {Object} 返回进行矩阵变换后的画布坐标
|
||
*/
|
||
|
||
}, {
|
||
key: "convert",
|
||
value: function convert(point) {
|
||
var _this$convertPoint = this.convertPoint(point),
|
||
x = _this$convertPoint.x,
|
||
y = _this$convertPoint.y;
|
||
|
||
var vector = this.applyMatrix(x, y, 1);
|
||
return {
|
||
x: vector[0],
|
||
y: vector[1]
|
||
};
|
||
}
|
||
/**
|
||
* 将进行过矩阵变换画布坐标转换为归一化坐标
|
||
* @param {Object} point 画布坐标
|
||
* @return {Object} 返回归一化的坐标点
|
||
*/
|
||
|
||
}, {
|
||
key: "invert",
|
||
value: function invert(point) {
|
||
var vector = this.invertMatrix(point.x, point.y, 1);
|
||
return this.invertPoint({
|
||
x: vector[0],
|
||
y: vector[1]
|
||
});
|
||
}
|
||
/**
|
||
* 坐标系旋转变换
|
||
* @param {Number} radian 旋转弧度
|
||
* @return {Object} 返回坐标系对象
|
||
*/
|
||
|
||
}, {
|
||
key: "rotate",
|
||
value: function rotate(radian) {
|
||
var matrix = this.matrix;
|
||
var center = this.center;
|
||
mat3.translate(matrix, matrix, [-center.x, -center.y]);
|
||
mat3.rotate(matrix, matrix, radian);
|
||
mat3.translate(matrix, matrix, [center.x, center.y]);
|
||
return this;
|
||
}
|
||
/**
|
||
* 坐标系反射变换
|
||
* @param {String} dim 反射维度
|
||
* @return {Object} 返回坐标系对象
|
||
*/
|
||
|
||
}, {
|
||
key: "reflect",
|
||
value: function reflect(dim) {
|
||
switch (dim) {
|
||
case 'x':
|
||
this._swapDim('x');
|
||
|
||
break;
|
||
|
||
case 'y':
|
||
this._swapDim('y');
|
||
|
||
break;
|
||
|
||
default:
|
||
this._swapDim('y');
|
||
|
||
}
|
||
|
||
return this;
|
||
}
|
||
/**
|
||
* 坐标系比例变换
|
||
* @param {Number} s1 x 方向缩放比例
|
||
* @param {Number} s2 y 方向缩放比例
|
||
* @return {Object} 返回坐标系对象
|
||
*/
|
||
|
||
}, {
|
||
key: "scale",
|
||
value: function scale(s1, s2) {
|
||
var matrix = this.matrix;
|
||
var center = this.center;
|
||
mat3.translate(matrix, matrix, [-center.x, -center.y]);
|
||
mat3.scale(matrix, matrix, [s1, s2]);
|
||
mat3.translate(matrix, matrix, [center.x, center.y]);
|
||
return this;
|
||
}
|
||
/**
|
||
* 坐标系平移变换
|
||
* @param {Number} x x 方向平移像素
|
||
* @param {Number} y y 方向平移像素
|
||
* @return {Object} 返回坐标系对象
|
||
*/
|
||
|
||
}, {
|
||
key: "translate",
|
||
value: function translate(x, y) {
|
||
var matrix = this.matrix;
|
||
mat3.translate(matrix, matrix, [x, y]);
|
||
return this;
|
||
}
|
||
/**
|
||
* 将坐标系 x y 两个轴进行转置
|
||
* @return {Object} 返回坐标系对象
|
||
*/
|
||
|
||
}, {
|
||
key: "transpose",
|
||
value: function transpose() {
|
||
this.isTransposed = !this.isTransposed;
|
||
return this;
|
||
}
|
||
}]);
|
||
|
||
return Coord;
|
||
}();
|
||
|
||
module.exports = Coord;
|
||
|
||
/***/ }),
|
||
/* 1 */
|
||
/***/ (function(module, exports) {
|
||
|
||
function _mix(dist, obj) {
|
||
for (var key in obj) {
|
||
if (obj.hasOwnProperty(key) && key !== 'constructor' && obj[key] !== undefined) {
|
||
dist[key] = obj[key];
|
||
}
|
||
}
|
||
}
|
||
|
||
var mix = function mix(dist, src1, src2, src3) {
|
||
if (src1) _mix(dist, src1);
|
||
if (src2) _mix(dist, src2);
|
||
if (src3) _mix(dist, src3);
|
||
return dist;
|
||
};
|
||
|
||
module.exports = mix;
|
||
|
||
/***/ }),
|
||
/* 2 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
module.exports = {
|
||
mat3: __webpack_require__(4),
|
||
vec2: __webpack_require__(9),
|
||
vec3: __webpack_require__(12),
|
||
transform: __webpack_require__(14)
|
||
};
|
||
|
||
/***/ }),
|
||
/* 3 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
|
||
Object.defineProperty(exports, "__esModule", {
|
||
value: true
|
||
});
|
||
exports.setMatrixArrayType = setMatrixArrayType;
|
||
exports.toRadian = toRadian;
|
||
exports.equals = equals;
|
||
/**
|
||
* Common utilities
|
||
* @module glMatrix
|
||
*/
|
||
// Configuration Constants
|
||
|
||
var EPSILON = exports.EPSILON = 0.000001;
|
||
var ARRAY_TYPE = exports.ARRAY_TYPE = typeof Float32Array !== 'undefined' ? Float32Array : Array;
|
||
var RANDOM = exports.RANDOM = Math.random;
|
||
/**
|
||
* Sets the type of array used when creating new vectors and matrices
|
||
*
|
||
* @param {Type} type Array type, such as Float32Array or Array
|
||
*/
|
||
|
||
function setMatrixArrayType(type) {
|
||
exports.ARRAY_TYPE = ARRAY_TYPE = type;
|
||
}
|
||
|
||
var degree = Math.PI / 180;
|
||
/**
|
||
* Convert Degree To Radian
|
||
*
|
||
* @param {Number} a Angle in Degrees
|
||
*/
|
||
|
||
function toRadian(a) {
|
||
return a * degree;
|
||
}
|
||
/**
|
||
* Tests whether or not the arguments have approximately the same value, within an absolute
|
||
* or relative tolerance of glMatrix.EPSILON (an absolute tolerance is used for values less
|
||
* than or equal to 1.0, and a relative tolerance is used for larger values)
|
||
*
|
||
* @param {Number} a The first number to test.
|
||
* @param {Number} b The second number to test.
|
||
* @returns {Boolean} True if the numbers are approximately equal, false otherwise.
|
||
*/
|
||
|
||
|
||
function equals(a, b) {
|
||
return Math.abs(a - b) <= EPSILON * Math.max(1.0, Math.abs(a), Math.abs(b));
|
||
}
|
||
|
||
/***/ }),
|
||
/* 4 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
var mat3 = __webpack_require__(8);
|
||
|
||
mat3.translate = function (out, a, v) {
|
||
var transMat = new Array(9);
|
||
mat3.fromTranslation(transMat, v);
|
||
return mat3.multiply(out, transMat, a);
|
||
};
|
||
|
||
mat3.rotate = function (out, a, rad) {
|
||
var rotateMat = new Array(9);
|
||
mat3.fromRotation(rotateMat, rad);
|
||
return mat3.multiply(out, rotateMat, a);
|
||
};
|
||
|
||
mat3.scale = function (out, a, v) {
|
||
var scaleMat = new Array(9);
|
||
mat3.fromScaling(scaleMat, v);
|
||
return mat3.multiply(out, scaleMat, a);
|
||
};
|
||
|
||
module.exports = mat3;
|
||
|
||
/***/ }),
|
||
/* 5 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
var isType = __webpack_require__(16);
|
||
|
||
var isArray = Array.isArray ? Array.isArray : function (value) {
|
||
return isType(value, 'Array');
|
||
};
|
||
module.exports = isArray;
|
||
|
||
/***/ }),
|
||
/* 6 */
|
||
/***/ (function(module, exports) {
|
||
|
||
var PRECISION = 0.00001; // numbers less than this is considered as 0
|
||
|
||
module.exports = function isNumberEqual(a, b) {
|
||
var precision = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : PRECISION;
|
||
return Math.abs(a - b) < precision;
|
||
};
|
||
|
||
/***/ }),
|
||
/* 7 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
/**
|
||
* @fileOverview the entry of coordinate
|
||
* @author sima.zhang1990@gmail.com
|
||
*/
|
||
var Coord = __webpack_require__(0);
|
||
|
||
Coord.Cartesian = __webpack_require__(19);
|
||
Coord.Rect = Coord.Cartesian;
|
||
Coord.Polar = __webpack_require__(20);
|
||
Coord.Helix = __webpack_require__(21);
|
||
module.exports = Coord;
|
||
|
||
/***/ }),
|
||
/* 8 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
|
||
Object.defineProperty(exports, "__esModule", {
|
||
value: true
|
||
});
|
||
exports.sub = exports.mul = undefined;
|
||
exports.create = create;
|
||
exports.fromMat4 = fromMat4;
|
||
exports.clone = clone;
|
||
exports.copy = copy;
|
||
exports.fromValues = fromValues;
|
||
exports.set = set;
|
||
exports.identity = identity;
|
||
exports.transpose = transpose;
|
||
exports.invert = invert;
|
||
exports.adjoint = adjoint;
|
||
exports.determinant = determinant;
|
||
exports.multiply = multiply;
|
||
exports.translate = translate;
|
||
exports.rotate = rotate;
|
||
exports.scale = scale;
|
||
exports.fromTranslation = fromTranslation;
|
||
exports.fromRotation = fromRotation;
|
||
exports.fromScaling = fromScaling;
|
||
exports.fromMat2d = fromMat2d;
|
||
exports.fromQuat = fromQuat;
|
||
exports.normalFromMat4 = normalFromMat4;
|
||
exports.projection = projection;
|
||
exports.str = str;
|
||
exports.frob = frob;
|
||
exports.add = add;
|
||
exports.subtract = subtract;
|
||
exports.multiplyScalar = multiplyScalar;
|
||
exports.multiplyScalarAndAdd = multiplyScalarAndAdd;
|
||
exports.exactEquals = exactEquals;
|
||
exports.equals = equals;
|
||
|
||
var _common = __webpack_require__(3);
|
||
|
||
var glMatrix = _interopRequireWildcard(_common);
|
||
|
||
function _interopRequireWildcard(obj) {
|
||
if (obj && obj.__esModule) {
|
||
return obj;
|
||
} else {
|
||
var newObj = {};
|
||
|
||
if (obj != null) {
|
||
for (var key in obj) {
|
||
if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key];
|
||
}
|
||
}
|
||
|
||
newObj.default = obj;
|
||
return newObj;
|
||
}
|
||
}
|
||
/**
|
||
* 3x3 Matrix
|
||
* @module mat3
|
||
*/
|
||
|
||
/**
|
||
* Creates a new identity mat3
|
||
*
|
||
* @returns {mat3} a new 3x3 matrix
|
||
*/
|
||
|
||
|
||
function create() {
|
||
var out = new glMatrix.ARRAY_TYPE(9);
|
||
|
||
if (glMatrix.ARRAY_TYPE != Float32Array) {
|
||
out[1] = 0;
|
||
out[2] = 0;
|
||
out[3] = 0;
|
||
out[5] = 0;
|
||
out[6] = 0;
|
||
out[7] = 0;
|
||
}
|
||
|
||
out[0] = 1;
|
||
out[4] = 1;
|
||
out[8] = 1;
|
||
return out;
|
||
}
|
||
/**
|
||
* Copies the upper-left 3x3 values into the given mat3.
|
||
*
|
||
* @param {mat3} out the receiving 3x3 matrix
|
||
* @param {mat4} a the source 4x4 matrix
|
||
* @returns {mat3} out
|
||
*/
|
||
|
||
|
||
function fromMat4(out, a) {
|
||
out[0] = a[0];
|
||
out[1] = a[1];
|
||
out[2] = a[2];
|
||
out[3] = a[4];
|
||
out[4] = a[5];
|
||
out[5] = a[6];
|
||
out[6] = a[8];
|
||
out[7] = a[9];
|
||
out[8] = a[10];
|
||
return out;
|
||
}
|
||
/**
|
||
* Creates a new mat3 initialized with values from an existing matrix
|
||
*
|
||
* @param {mat3} a matrix to clone
|
||
* @returns {mat3} a new 3x3 matrix
|
||
*/
|
||
|
||
|
||
function clone(a) {
|
||
var out = new glMatrix.ARRAY_TYPE(9);
|
||
out[0] = a[0];
|
||
out[1] = a[1];
|
||
out[2] = a[2];
|
||
out[3] = a[3];
|
||
out[4] = a[4];
|
||
out[5] = a[5];
|
||
out[6] = a[6];
|
||
out[7] = a[7];
|
||
out[8] = a[8];
|
||
return out;
|
||
}
|
||
/**
|
||
* Copy the values from one mat3 to another
|
||
*
|
||
* @param {mat3} out the receiving matrix
|
||
* @param {mat3} a the source matrix
|
||
* @returns {mat3} out
|
||
*/
|
||
|
||
|
||
function copy(out, a) {
|
||
out[0] = a[0];
|
||
out[1] = a[1];
|
||
out[2] = a[2];
|
||
out[3] = a[3];
|
||
out[4] = a[4];
|
||
out[5] = a[5];
|
||
out[6] = a[6];
|
||
out[7] = a[7];
|
||
out[8] = a[8];
|
||
return out;
|
||
}
|
||
/**
|
||
* Create a new mat3 with the given values
|
||
*
|
||
* @param {Number} m00 Component in column 0, row 0 position (index 0)
|
||
* @param {Number} m01 Component in column 0, row 1 position (index 1)
|
||
* @param {Number} m02 Component in column 0, row 2 position (index 2)
|
||
* @param {Number} m10 Component in column 1, row 0 position (index 3)
|
||
* @param {Number} m11 Component in column 1, row 1 position (index 4)
|
||
* @param {Number} m12 Component in column 1, row 2 position (index 5)
|
||
* @param {Number} m20 Component in column 2, row 0 position (index 6)
|
||
* @param {Number} m21 Component in column 2, row 1 position (index 7)
|
||
* @param {Number} m22 Component in column 2, row 2 position (index 8)
|
||
* @returns {mat3} A new mat3
|
||
*/
|
||
|
||
|
||
function fromValues(m00, m01, m02, m10, m11, m12, m20, m21, m22) {
|
||
var out = new glMatrix.ARRAY_TYPE(9);
|
||
out[0] = m00;
|
||
out[1] = m01;
|
||
out[2] = m02;
|
||
out[3] = m10;
|
||
out[4] = m11;
|
||
out[5] = m12;
|
||
out[6] = m20;
|
||
out[7] = m21;
|
||
out[8] = m22;
|
||
return out;
|
||
}
|
||
/**
|
||
* Set the components of a mat3 to the given values
|
||
*
|
||
* @param {mat3} out the receiving matrix
|
||
* @param {Number} m00 Component in column 0, row 0 position (index 0)
|
||
* @param {Number} m01 Component in column 0, row 1 position (index 1)
|
||
* @param {Number} m02 Component in column 0, row 2 position (index 2)
|
||
* @param {Number} m10 Component in column 1, row 0 position (index 3)
|
||
* @param {Number} m11 Component in column 1, row 1 position (index 4)
|
||
* @param {Number} m12 Component in column 1, row 2 position (index 5)
|
||
* @param {Number} m20 Component in column 2, row 0 position (index 6)
|
||
* @param {Number} m21 Component in column 2, row 1 position (index 7)
|
||
* @param {Number} m22 Component in column 2, row 2 position (index 8)
|
||
* @returns {mat3} out
|
||
*/
|
||
|
||
|
||
function set(out, m00, m01, m02, m10, m11, m12, m20, m21, m22) {
|
||
out[0] = m00;
|
||
out[1] = m01;
|
||
out[2] = m02;
|
||
out[3] = m10;
|
||
out[4] = m11;
|
||
out[5] = m12;
|
||
out[6] = m20;
|
||
out[7] = m21;
|
||
out[8] = m22;
|
||
return out;
|
||
}
|
||
/**
|
||
* Set a mat3 to the identity matrix
|
||
*
|
||
* @param {mat3} out the receiving matrix
|
||
* @returns {mat3} out
|
||
*/
|
||
|
||
|
||
function identity(out) {
|
||
out[0] = 1;
|
||
out[1] = 0;
|
||
out[2] = 0;
|
||
out[3] = 0;
|
||
out[4] = 1;
|
||
out[5] = 0;
|
||
out[6] = 0;
|
||
out[7] = 0;
|
||
out[8] = 1;
|
||
return out;
|
||
}
|
||
/**
|
||
* Transpose the values of a mat3
|
||
*
|
||
* @param {mat3} out the receiving matrix
|
||
* @param {mat3} a the source matrix
|
||
* @returns {mat3} out
|
||
*/
|
||
|
||
|
||
function transpose(out, a) {
|
||
// If we are transposing ourselves we can skip a few steps but have to cache some values
|
||
if (out === a) {
|
||
var a01 = a[1],
|
||
a02 = a[2],
|
||
a12 = a[5];
|
||
out[1] = a[3];
|
||
out[2] = a[6];
|
||
out[3] = a01;
|
||
out[5] = a[7];
|
||
out[6] = a02;
|
||
out[7] = a12;
|
||
} else {
|
||
out[0] = a[0];
|
||
out[1] = a[3];
|
||
out[2] = a[6];
|
||
out[3] = a[1];
|
||
out[4] = a[4];
|
||
out[5] = a[7];
|
||
out[6] = a[2];
|
||
out[7] = a[5];
|
||
out[8] = a[8];
|
||
}
|
||
|
||
return out;
|
||
}
|
||
/**
|
||
* Inverts a mat3
|
||
*
|
||
* @param {mat3} out the receiving matrix
|
||
* @param {mat3} a the source matrix
|
||
* @returns {mat3} out
|
||
*/
|
||
|
||
|
||
function invert(out, a) {
|
||
var a00 = a[0],
|
||
a01 = a[1],
|
||
a02 = a[2];
|
||
var a10 = a[3],
|
||
a11 = a[4],
|
||
a12 = a[5];
|
||
var a20 = a[6],
|
||
a21 = a[7],
|
||
a22 = a[8];
|
||
var b01 = a22 * a11 - a12 * a21;
|
||
var b11 = -a22 * a10 + a12 * a20;
|
||
var b21 = a21 * a10 - a11 * a20; // Calculate the determinant
|
||
|
||
var det = a00 * b01 + a01 * b11 + a02 * b21;
|
||
|
||
if (!det) {
|
||
return null;
|
||
}
|
||
|
||
det = 1.0 / det;
|
||
out[0] = b01 * det;
|
||
out[1] = (-a22 * a01 + a02 * a21) * det;
|
||
out[2] = (a12 * a01 - a02 * a11) * det;
|
||
out[3] = b11 * det;
|
||
out[4] = (a22 * a00 - a02 * a20) * det;
|
||
out[5] = (-a12 * a00 + a02 * a10) * det;
|
||
out[6] = b21 * det;
|
||
out[7] = (-a21 * a00 + a01 * a20) * det;
|
||
out[8] = (a11 * a00 - a01 * a10) * det;
|
||
return out;
|
||
}
|
||
/**
|
||
* Calculates the adjugate of a mat3
|
||
*
|
||
* @param {mat3} out the receiving matrix
|
||
* @param {mat3} a the source matrix
|
||
* @returns {mat3} out
|
||
*/
|
||
|
||
|
||
function adjoint(out, a) {
|
||
var a00 = a[0],
|
||
a01 = a[1],
|
||
a02 = a[2];
|
||
var a10 = a[3],
|
||
a11 = a[4],
|
||
a12 = a[5];
|
||
var a20 = a[6],
|
||
a21 = a[7],
|
||
a22 = a[8];
|
||
out[0] = a11 * a22 - a12 * a21;
|
||
out[1] = a02 * a21 - a01 * a22;
|
||
out[2] = a01 * a12 - a02 * a11;
|
||
out[3] = a12 * a20 - a10 * a22;
|
||
out[4] = a00 * a22 - a02 * a20;
|
||
out[5] = a02 * a10 - a00 * a12;
|
||
out[6] = a10 * a21 - a11 * a20;
|
||
out[7] = a01 * a20 - a00 * a21;
|
||
out[8] = a00 * a11 - a01 * a10;
|
||
return out;
|
||
}
|
||
/**
|
||
* Calculates the determinant of a mat3
|
||
*
|
||
* @param {mat3} a the source matrix
|
||
* @returns {Number} determinant of a
|
||
*/
|
||
|
||
|
||
function determinant(a) {
|
||
var a00 = a[0],
|
||
a01 = a[1],
|
||
a02 = a[2];
|
||
var a10 = a[3],
|
||
a11 = a[4],
|
||
a12 = a[5];
|
||
var a20 = a[6],
|
||
a21 = a[7],
|
||
a22 = a[8];
|
||
return a00 * (a22 * a11 - a12 * a21) + a01 * (-a22 * a10 + a12 * a20) + a02 * (a21 * a10 - a11 * a20);
|
||
}
|
||
/**
|
||
* Multiplies two mat3's
|
||
*
|
||
* @param {mat3} out the receiving matrix
|
||
* @param {mat3} a the first operand
|
||
* @param {mat3} b the second operand
|
||
* @returns {mat3} out
|
||
*/
|
||
|
||
|
||
function multiply(out, a, b) {
|
||
var a00 = a[0],
|
||
a01 = a[1],
|
||
a02 = a[2];
|
||
var a10 = a[3],
|
||
a11 = a[4],
|
||
a12 = a[5];
|
||
var a20 = a[6],
|
||
a21 = a[7],
|
||
a22 = a[8];
|
||
var b00 = b[0],
|
||
b01 = b[1],
|
||
b02 = b[2];
|
||
var b10 = b[3],
|
||
b11 = b[4],
|
||
b12 = b[5];
|
||
var b20 = b[6],
|
||
b21 = b[7],
|
||
b22 = b[8];
|
||
out[0] = b00 * a00 + b01 * a10 + b02 * a20;
|
||
out[1] = b00 * a01 + b01 * a11 + b02 * a21;
|
||
out[2] = b00 * a02 + b01 * a12 + b02 * a22;
|
||
out[3] = b10 * a00 + b11 * a10 + b12 * a20;
|
||
out[4] = b10 * a01 + b11 * a11 + b12 * a21;
|
||
out[5] = b10 * a02 + b11 * a12 + b12 * a22;
|
||
out[6] = b20 * a00 + b21 * a10 + b22 * a20;
|
||
out[7] = b20 * a01 + b21 * a11 + b22 * a21;
|
||
out[8] = b20 * a02 + b21 * a12 + b22 * a22;
|
||
return out;
|
||
}
|
||
/**
|
||
* Translate a mat3 by the given vector
|
||
*
|
||
* @param {mat3} out the receiving matrix
|
||
* @param {mat3} a the matrix to translate
|
||
* @param {vec2} v vector to translate by
|
||
* @returns {mat3} out
|
||
*/
|
||
|
||
|
||
function translate(out, a, v) {
|
||
var a00 = a[0],
|
||
a01 = a[1],
|
||
a02 = a[2],
|
||
a10 = a[3],
|
||
a11 = a[4],
|
||
a12 = a[5],
|
||
a20 = a[6],
|
||
a21 = a[7],
|
||
a22 = a[8],
|
||
x = v[0],
|
||
y = v[1];
|
||
out[0] = a00;
|
||
out[1] = a01;
|
||
out[2] = a02;
|
||
out[3] = a10;
|
||
out[4] = a11;
|
||
out[5] = a12;
|
||
out[6] = x * a00 + y * a10 + a20;
|
||
out[7] = x * a01 + y * a11 + a21;
|
||
out[8] = x * a02 + y * a12 + a22;
|
||
return out;
|
||
}
|
||
/**
|
||
* Rotates a mat3 by the given angle
|
||
*
|
||
* @param {mat3} out the receiving matrix
|
||
* @param {mat3} a the matrix to rotate
|
||
* @param {Number} rad the angle to rotate the matrix by
|
||
* @returns {mat3} out
|
||
*/
|
||
|
||
|
||
function rotate(out, a, rad) {
|
||
var a00 = a[0],
|
||
a01 = a[1],
|
||
a02 = a[2],
|
||
a10 = a[3],
|
||
a11 = a[4],
|
||
a12 = a[5],
|
||
a20 = a[6],
|
||
a21 = a[7],
|
||
a22 = a[8],
|
||
s = Math.sin(rad),
|
||
c = Math.cos(rad);
|
||
out[0] = c * a00 + s * a10;
|
||
out[1] = c * a01 + s * a11;
|
||
out[2] = c * a02 + s * a12;
|
||
out[3] = c * a10 - s * a00;
|
||
out[4] = c * a11 - s * a01;
|
||
out[5] = c * a12 - s * a02;
|
||
out[6] = a20;
|
||
out[7] = a21;
|
||
out[8] = a22;
|
||
return out;
|
||
}
|
||
|
||
;
|
||
/**
|
||
* Scales the mat3 by the dimensions in the given vec2
|
||
*
|
||
* @param {mat3} out the receiving matrix
|
||
* @param {mat3} a the matrix to rotate
|
||
* @param {vec2} v the vec2 to scale the matrix by
|
||
* @returns {mat3} out
|
||
**/
|
||
|
||
function scale(out, a, v) {
|
||
var x = v[0],
|
||
y = v[1];
|
||
out[0] = x * a[0];
|
||
out[1] = x * a[1];
|
||
out[2] = x * a[2];
|
||
out[3] = y * a[3];
|
||
out[4] = y * a[4];
|
||
out[5] = y * a[5];
|
||
out[6] = a[6];
|
||
out[7] = a[7];
|
||
out[8] = a[8];
|
||
return out;
|
||
}
|
||
/**
|
||
* Creates a matrix from a vector translation
|
||
* This is equivalent to (but much faster than):
|
||
*
|
||
* mat3.identity(dest);
|
||
* mat3.translate(dest, dest, vec);
|
||
*
|
||
* @param {mat3} out mat3 receiving operation result
|
||
* @param {vec2} v Translation vector
|
||
* @returns {mat3} out
|
||
*/
|
||
|
||
|
||
function fromTranslation(out, v) {
|
||
out[0] = 1;
|
||
out[1] = 0;
|
||
out[2] = 0;
|
||
out[3] = 0;
|
||
out[4] = 1;
|
||
out[5] = 0;
|
||
out[6] = v[0];
|
||
out[7] = v[1];
|
||
out[8] = 1;
|
||
return out;
|
||
}
|
||
/**
|
||
* Creates a matrix from a given angle
|
||
* This is equivalent to (but much faster than):
|
||
*
|
||
* mat3.identity(dest);
|
||
* mat3.rotate(dest, dest, rad);
|
||
*
|
||
* @param {mat3} out mat3 receiving operation result
|
||
* @param {Number} rad the angle to rotate the matrix by
|
||
* @returns {mat3} out
|
||
*/
|
||
|
||
|
||
function fromRotation(out, rad) {
|
||
var s = Math.sin(rad),
|
||
c = Math.cos(rad);
|
||
out[0] = c;
|
||
out[1] = s;
|
||
out[2] = 0;
|
||
out[3] = -s;
|
||
out[4] = c;
|
||
out[5] = 0;
|
||
out[6] = 0;
|
||
out[7] = 0;
|
||
out[8] = 1;
|
||
return out;
|
||
}
|
||
/**
|
||
* Creates a matrix from a vector scaling
|
||
* This is equivalent to (but much faster than):
|
||
*
|
||
* mat3.identity(dest);
|
||
* mat3.scale(dest, dest, vec);
|
||
*
|
||
* @param {mat3} out mat3 receiving operation result
|
||
* @param {vec2} v Scaling vector
|
||
* @returns {mat3} out
|
||
*/
|
||
|
||
|
||
function fromScaling(out, v) {
|
||
out[0] = v[0];
|
||
out[1] = 0;
|
||
out[2] = 0;
|
||
out[3] = 0;
|
||
out[4] = v[1];
|
||
out[5] = 0;
|
||
out[6] = 0;
|
||
out[7] = 0;
|
||
out[8] = 1;
|
||
return out;
|
||
}
|
||
/**
|
||
* Copies the values from a mat2d into a mat3
|
||
*
|
||
* @param {mat3} out the receiving matrix
|
||
* @param {mat2d} a the matrix to copy
|
||
* @returns {mat3} out
|
||
**/
|
||
|
||
|
||
function fromMat2d(out, a) {
|
||
out[0] = a[0];
|
||
out[1] = a[1];
|
||
out[2] = 0;
|
||
out[3] = a[2];
|
||
out[4] = a[3];
|
||
out[5] = 0;
|
||
out[6] = a[4];
|
||
out[7] = a[5];
|
||
out[8] = 1;
|
||
return out;
|
||
}
|
||
/**
|
||
* Calculates a 3x3 matrix from the given quaternion
|
||
*
|
||
* @param {mat3} out mat3 receiving operation result
|
||
* @param {quat} q Quaternion to create matrix from
|
||
*
|
||
* @returns {mat3} out
|
||
*/
|
||
|
||
|
||
function fromQuat(out, q) {
|
||
var x = q[0],
|
||
y = q[1],
|
||
z = q[2],
|
||
w = q[3];
|
||
var x2 = x + x;
|
||
var y2 = y + y;
|
||
var z2 = z + z;
|
||
var xx = x * x2;
|
||
var yx = y * x2;
|
||
var yy = y * y2;
|
||
var zx = z * x2;
|
||
var zy = z * y2;
|
||
var zz = z * z2;
|
||
var wx = w * x2;
|
||
var wy = w * y2;
|
||
var wz = w * z2;
|
||
out[0] = 1 - yy - zz;
|
||
out[3] = yx - wz;
|
||
out[6] = zx + wy;
|
||
out[1] = yx + wz;
|
||
out[4] = 1 - xx - zz;
|
||
out[7] = zy - wx;
|
||
out[2] = zx - wy;
|
||
out[5] = zy + wx;
|
||
out[8] = 1 - xx - yy;
|
||
return out;
|
||
}
|
||
/**
|
||
* Calculates a 3x3 normal matrix (transpose inverse) from the 4x4 matrix
|
||
*
|
||
* @param {mat3} out mat3 receiving operation result
|
||
* @param {mat4} a Mat4 to derive the normal matrix from
|
||
*
|
||
* @returns {mat3} out
|
||
*/
|
||
|
||
|
||
function normalFromMat4(out, a) {
|
||
var a00 = a[0],
|
||
a01 = a[1],
|
||
a02 = a[2],
|
||
a03 = a[3];
|
||
var a10 = a[4],
|
||
a11 = a[5],
|
||
a12 = a[6],
|
||
a13 = a[7];
|
||
var a20 = a[8],
|
||
a21 = a[9],
|
||
a22 = a[10],
|
||
a23 = a[11];
|
||
var a30 = a[12],
|
||
a31 = a[13],
|
||
a32 = a[14],
|
||
a33 = a[15];
|
||
var b00 = a00 * a11 - a01 * a10;
|
||
var b01 = a00 * a12 - a02 * a10;
|
||
var b02 = a00 * a13 - a03 * a10;
|
||
var b03 = a01 * a12 - a02 * a11;
|
||
var b04 = a01 * a13 - a03 * a11;
|
||
var b05 = a02 * a13 - a03 * a12;
|
||
var b06 = a20 * a31 - a21 * a30;
|
||
var b07 = a20 * a32 - a22 * a30;
|
||
var b08 = a20 * a33 - a23 * a30;
|
||
var b09 = a21 * a32 - a22 * a31;
|
||
var b10 = a21 * a33 - a23 * a31;
|
||
var b11 = a22 * a33 - a23 * a32; // Calculate the determinant
|
||
|
||
var det = b00 * b11 - b01 * b10 + b02 * b09 + b03 * b08 - b04 * b07 + b05 * b06;
|
||
|
||
if (!det) {
|
||
return null;
|
||
}
|
||
|
||
det = 1.0 / det;
|
||
out[0] = (a11 * b11 - a12 * b10 + a13 * b09) * det;
|
||
out[1] = (a12 * b08 - a10 * b11 - a13 * b07) * det;
|
||
out[2] = (a10 * b10 - a11 * b08 + a13 * b06) * det;
|
||
out[3] = (a02 * b10 - a01 * b11 - a03 * b09) * det;
|
||
out[4] = (a00 * b11 - a02 * b08 + a03 * b07) * det;
|
||
out[5] = (a01 * b08 - a00 * b10 - a03 * b06) * det;
|
||
out[6] = (a31 * b05 - a32 * b04 + a33 * b03) * det;
|
||
out[7] = (a32 * b02 - a30 * b05 - a33 * b01) * det;
|
||
out[8] = (a30 * b04 - a31 * b02 + a33 * b00) * det;
|
||
return out;
|
||
}
|
||
/**
|
||
* Generates a 2D projection matrix with the given bounds
|
||
*
|
||
* @param {mat3} out mat3 frustum matrix will be written into
|
||
* @param {number} width Width of your gl context
|
||
* @param {number} height Height of gl context
|
||
* @returns {mat3} out
|
||
*/
|
||
|
||
|
||
function projection(out, width, height) {
|
||
out[0] = 2 / width;
|
||
out[1] = 0;
|
||
out[2] = 0;
|
||
out[3] = 0;
|
||
out[4] = -2 / height;
|
||
out[5] = 0;
|
||
out[6] = -1;
|
||
out[7] = 1;
|
||
out[8] = 1;
|
||
return out;
|
||
}
|
||
/**
|
||
* Returns a string representation of a mat3
|
||
*
|
||
* @param {mat3} a matrix to represent as a string
|
||
* @returns {String} string representation of the matrix
|
||
*/
|
||
|
||
|
||
function str(a) {
|
||
return 'mat3(' + a[0] + ', ' + a[1] + ', ' + a[2] + ', ' + a[3] + ', ' + a[4] + ', ' + a[5] + ', ' + a[6] + ', ' + a[7] + ', ' + a[8] + ')';
|
||
}
|
||
/**
|
||
* Returns Frobenius norm of a mat3
|
||
*
|
||
* @param {mat3} a the matrix to calculate Frobenius norm of
|
||
* @returns {Number} Frobenius norm
|
||
*/
|
||
|
||
|
||
function frob(a) {
|
||
return Math.sqrt(Math.pow(a[0], 2) + Math.pow(a[1], 2) + Math.pow(a[2], 2) + Math.pow(a[3], 2) + Math.pow(a[4], 2) + Math.pow(a[5], 2) + Math.pow(a[6], 2) + Math.pow(a[7], 2) + Math.pow(a[8], 2));
|
||
}
|
||
/**
|
||
* Adds two mat3's
|
||
*
|
||
* @param {mat3} out the receiving matrix
|
||
* @param {mat3} a the first operand
|
||
* @param {mat3} b the second operand
|
||
* @returns {mat3} out
|
||
*/
|
||
|
||
|
||
function add(out, a, b) {
|
||
out[0] = a[0] + b[0];
|
||
out[1] = a[1] + b[1];
|
||
out[2] = a[2] + b[2];
|
||
out[3] = a[3] + b[3];
|
||
out[4] = a[4] + b[4];
|
||
out[5] = a[5] + b[5];
|
||
out[6] = a[6] + b[6];
|
||
out[7] = a[7] + b[7];
|
||
out[8] = a[8] + b[8];
|
||
return out;
|
||
}
|
||
/**
|
||
* Subtracts matrix b from matrix a
|
||
*
|
||
* @param {mat3} out the receiving matrix
|
||
* @param {mat3} a the first operand
|
||
* @param {mat3} b the second operand
|
||
* @returns {mat3} out
|
||
*/
|
||
|
||
|
||
function subtract(out, a, b) {
|
||
out[0] = a[0] - b[0];
|
||
out[1] = a[1] - b[1];
|
||
out[2] = a[2] - b[2];
|
||
out[3] = a[3] - b[3];
|
||
out[4] = a[4] - b[4];
|
||
out[5] = a[5] - b[5];
|
||
out[6] = a[6] - b[6];
|
||
out[7] = a[7] - b[7];
|
||
out[8] = a[8] - b[8];
|
||
return out;
|
||
}
|
||
/**
|
||
* Multiply each element of the matrix by a scalar.
|
||
*
|
||
* @param {mat3} out the receiving matrix
|
||
* @param {mat3} a the matrix to scale
|
||
* @param {Number} b amount to scale the matrix's elements by
|
||
* @returns {mat3} out
|
||
*/
|
||
|
||
|
||
function multiplyScalar(out, a, b) {
|
||
out[0] = a[0] * b;
|
||
out[1] = a[1] * b;
|
||
out[2] = a[2] * b;
|
||
out[3] = a[3] * b;
|
||
out[4] = a[4] * b;
|
||
out[5] = a[5] * b;
|
||
out[6] = a[6] * b;
|
||
out[7] = a[7] * b;
|
||
out[8] = a[8] * b;
|
||
return out;
|
||
}
|
||
/**
|
||
* Adds two mat3's after multiplying each element of the second operand by a scalar value.
|
||
*
|
||
* @param {mat3} out the receiving vector
|
||
* @param {mat3} a the first operand
|
||
* @param {mat3} b the second operand
|
||
* @param {Number} scale the amount to scale b's elements by before adding
|
||
* @returns {mat3} out
|
||
*/
|
||
|
||
|
||
function multiplyScalarAndAdd(out, a, b, scale) {
|
||
out[0] = a[0] + b[0] * scale;
|
||
out[1] = a[1] + b[1] * scale;
|
||
out[2] = a[2] + b[2] * scale;
|
||
out[3] = a[3] + b[3] * scale;
|
||
out[4] = a[4] + b[4] * scale;
|
||
out[5] = a[5] + b[5] * scale;
|
||
out[6] = a[6] + b[6] * scale;
|
||
out[7] = a[7] + b[7] * scale;
|
||
out[8] = a[8] + b[8] * scale;
|
||
return out;
|
||
}
|
||
/**
|
||
* Returns whether or not the matrices have exactly the same elements in the same position (when compared with ===)
|
||
*
|
||
* @param {mat3} a The first matrix.
|
||
* @param {mat3} b The second matrix.
|
||
* @returns {Boolean} True if the matrices are equal, false otherwise.
|
||
*/
|
||
|
||
|
||
function exactEquals(a, b) {
|
||
return a[0] === b[0] && a[1] === b[1] && a[2] === b[2] && a[3] === b[3] && a[4] === b[4] && a[5] === b[5] && a[6] === b[6] && a[7] === b[7] && a[8] === b[8];
|
||
}
|
||
/**
|
||
* Returns whether or not the matrices have approximately the same elements in the same position.
|
||
*
|
||
* @param {mat3} a The first matrix.
|
||
* @param {mat3} b The second matrix.
|
||
* @returns {Boolean} True if the matrices are equal, false otherwise.
|
||
*/
|
||
|
||
|
||
function equals(a, b) {
|
||
var a0 = a[0],
|
||
a1 = a[1],
|
||
a2 = a[2],
|
||
a3 = a[3],
|
||
a4 = a[4],
|
||
a5 = a[5],
|
||
a6 = a[6],
|
||
a7 = a[7],
|
||
a8 = a[8];
|
||
var b0 = b[0],
|
||
b1 = b[1],
|
||
b2 = b[2],
|
||
b3 = b[3],
|
||
b4 = b[4],
|
||
b5 = b[5],
|
||
b6 = b[6],
|
||
b7 = b[7],
|
||
b8 = b[8];
|
||
return Math.abs(a0 - b0) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a0), Math.abs(b0)) && Math.abs(a1 - b1) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a1), Math.abs(b1)) && Math.abs(a2 - b2) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a2), Math.abs(b2)) && Math.abs(a3 - b3) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a3), Math.abs(b3)) && Math.abs(a4 - b4) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a4), Math.abs(b4)) && Math.abs(a5 - b5) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a5), Math.abs(b5)) && Math.abs(a6 - b6) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a6), Math.abs(b6)) && Math.abs(a7 - b7) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a7), Math.abs(b7)) && Math.abs(a8 - b8) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a8), Math.abs(b8));
|
||
}
|
||
/**
|
||
* Alias for {@link mat3.multiply}
|
||
* @function
|
||
*/
|
||
|
||
|
||
var mul = exports.mul = multiply;
|
||
/**
|
||
* Alias for {@link mat3.subtract}
|
||
* @function
|
||
*/
|
||
|
||
var sub = exports.sub = subtract;
|
||
|
||
/***/ }),
|
||
/* 9 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
var vec2 = __webpack_require__(10);
|
||
|
||
var clamp = __webpack_require__(11);
|
||
|
||
vec2.angle = function (v1, v2) {
|
||
var theta = vec2.dot(v1, v2) / (vec2.length(v1) * vec2.length(v2));
|
||
return Math.acos(clamp(theta, -1, 1));
|
||
};
|
||
/**
|
||
* 向量 v1 到 向量 v2 夹角的方向
|
||
* @param {Array} v1 向量
|
||
* @param {Array} v2 向量
|
||
* @return {Boolean} >= 0 顺时针 < 0 逆时针
|
||
*/
|
||
|
||
|
||
vec2.direction = function (v1, v2) {
|
||
return v1[0] * v2[1] - v2[0] * v1[1];
|
||
};
|
||
|
||
vec2.angleTo = function (v1, v2, direct) {
|
||
var angle = vec2.angle(v1, v2);
|
||
var angleLargeThanPI = vec2.direction(v1, v2) >= 0;
|
||
|
||
if (direct) {
|
||
if (angleLargeThanPI) {
|
||
return Math.PI * 2 - angle;
|
||
}
|
||
|
||
return angle;
|
||
}
|
||
|
||
if (angleLargeThanPI) {
|
||
return angle;
|
||
}
|
||
|
||
return Math.PI * 2 - angle;
|
||
};
|
||
|
||
vec2.vertical = function (out, v, flag) {
|
||
if (flag) {
|
||
out[0] = v[1];
|
||
out[1] = -1 * v[0];
|
||
} else {
|
||
out[0] = -1 * v[1];
|
||
out[1] = v[0];
|
||
}
|
||
|
||
return out;
|
||
};
|
||
|
||
module.exports = vec2;
|
||
|
||
/***/ }),
|
||
/* 10 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
|
||
Object.defineProperty(exports, "__esModule", {
|
||
value: true
|
||
});
|
||
exports.forEach = exports.sqrLen = exports.sqrDist = exports.dist = exports.div = exports.mul = exports.sub = exports.len = undefined;
|
||
exports.create = create;
|
||
exports.clone = clone;
|
||
exports.fromValues = fromValues;
|
||
exports.copy = copy;
|
||
exports.set = set;
|
||
exports.add = add;
|
||
exports.subtract = subtract;
|
||
exports.multiply = multiply;
|
||
exports.divide = divide;
|
||
exports.ceil = ceil;
|
||
exports.floor = floor;
|
||
exports.min = min;
|
||
exports.max = max;
|
||
exports.round = round;
|
||
exports.scale = scale;
|
||
exports.scaleAndAdd = scaleAndAdd;
|
||
exports.distance = distance;
|
||
exports.squaredDistance = squaredDistance;
|
||
exports.length = length;
|
||
exports.squaredLength = squaredLength;
|
||
exports.negate = negate;
|
||
exports.inverse = inverse;
|
||
exports.normalize = normalize;
|
||
exports.dot = dot;
|
||
exports.cross = cross;
|
||
exports.lerp = lerp;
|
||
exports.random = random;
|
||
exports.transformMat2 = transformMat2;
|
||
exports.transformMat2d = transformMat2d;
|
||
exports.transformMat3 = transformMat3;
|
||
exports.transformMat4 = transformMat4;
|
||
exports.rotate = rotate;
|
||
exports.angle = angle;
|
||
exports.str = str;
|
||
exports.exactEquals = exactEquals;
|
||
exports.equals = equals;
|
||
|
||
var _common = __webpack_require__(3);
|
||
|
||
var glMatrix = _interopRequireWildcard(_common);
|
||
|
||
function _interopRequireWildcard(obj) {
|
||
if (obj && obj.__esModule) {
|
||
return obj;
|
||
} else {
|
||
var newObj = {};
|
||
|
||
if (obj != null) {
|
||
for (var key in obj) {
|
||
if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key];
|
||
}
|
||
}
|
||
|
||
newObj.default = obj;
|
||
return newObj;
|
||
}
|
||
}
|
||
/**
|
||
* 2 Dimensional Vector
|
||
* @module vec2
|
||
*/
|
||
|
||
/**
|
||
* Creates a new, empty vec2
|
||
*
|
||
* @returns {vec2} a new 2D vector
|
||
*/
|
||
|
||
|
||
function create() {
|
||
var out = new glMatrix.ARRAY_TYPE(2);
|
||
|
||
if (glMatrix.ARRAY_TYPE != Float32Array) {
|
||
out[0] = 0;
|
||
out[1] = 0;
|
||
}
|
||
|
||
return out;
|
||
}
|
||
/**
|
||
* Creates a new vec2 initialized with values from an existing vector
|
||
*
|
||
* @param {vec2} a vector to clone
|
||
* @returns {vec2} a new 2D vector
|
||
*/
|
||
|
||
|
||
function clone(a) {
|
||
var out = new glMatrix.ARRAY_TYPE(2);
|
||
out[0] = a[0];
|
||
out[1] = a[1];
|
||
return out;
|
||
}
|
||
/**
|
||
* Creates a new vec2 initialized with the given values
|
||
*
|
||
* @param {Number} x X component
|
||
* @param {Number} y Y component
|
||
* @returns {vec2} a new 2D vector
|
||
*/
|
||
|
||
|
||
function fromValues(x, y) {
|
||
var out = new glMatrix.ARRAY_TYPE(2);
|
||
out[0] = x;
|
||
out[1] = y;
|
||
return out;
|
||
}
|
||
/**
|
||
* Copy the values from one vec2 to another
|
||
*
|
||
* @param {vec2} out the receiving vector
|
||
* @param {vec2} a the source vector
|
||
* @returns {vec2} out
|
||
*/
|
||
|
||
|
||
function copy(out, a) {
|
||
out[0] = a[0];
|
||
out[1] = a[1];
|
||
return out;
|
||
}
|
||
/**
|
||
* Set the components of a vec2 to the given values
|
||
*
|
||
* @param {vec2} out the receiving vector
|
||
* @param {Number} x X component
|
||
* @param {Number} y Y component
|
||
* @returns {vec2} out
|
||
*/
|
||
|
||
|
||
function set(out, x, y) {
|
||
out[0] = x;
|
||
out[1] = y;
|
||
return out;
|
||
}
|
||
/**
|
||
* Adds two vec2's
|
||
*
|
||
* @param {vec2} out the receiving vector
|
||
* @param {vec2} a the first operand
|
||
* @param {vec2} b the second operand
|
||
* @returns {vec2} out
|
||
*/
|
||
|
||
|
||
function add(out, a, b) {
|
||
out[0] = a[0] + b[0];
|
||
out[1] = a[1] + b[1];
|
||
return out;
|
||
}
|
||
/**
|
||
* Subtracts vector b from vector a
|
||
*
|
||
* @param {vec2} out the receiving vector
|
||
* @param {vec2} a the first operand
|
||
* @param {vec2} b the second operand
|
||
* @returns {vec2} out
|
||
*/
|
||
|
||
|
||
function subtract(out, a, b) {
|
||
out[0] = a[0] - b[0];
|
||
out[1] = a[1] - b[1];
|
||
return out;
|
||
}
|
||
/**
|
||
* Multiplies two vec2's
|
||
*
|
||
* @param {vec2} out the receiving vector
|
||
* @param {vec2} a the first operand
|
||
* @param {vec2} b the second operand
|
||
* @returns {vec2} out
|
||
*/
|
||
|
||
|
||
function multiply(out, a, b) {
|
||
out[0] = a[0] * b[0];
|
||
out[1] = a[1] * b[1];
|
||
return out;
|
||
}
|
||
/**
|
||
* Divides two vec2's
|
||
*
|
||
* @param {vec2} out the receiving vector
|
||
* @param {vec2} a the first operand
|
||
* @param {vec2} b the second operand
|
||
* @returns {vec2} out
|
||
*/
|
||
|
||
|
||
function divide(out, a, b) {
|
||
out[0] = a[0] / b[0];
|
||
out[1] = a[1] / b[1];
|
||
return out;
|
||
}
|
||
/**
|
||
* Math.ceil the components of a vec2
|
||
*
|
||
* @param {vec2} out the receiving vector
|
||
* @param {vec2} a vector to ceil
|
||
* @returns {vec2} out
|
||
*/
|
||
|
||
|
||
function ceil(out, a) {
|
||
out[0] = Math.ceil(a[0]);
|
||
out[1] = Math.ceil(a[1]);
|
||
return out;
|
||
}
|
||
/**
|
||
* Math.floor the components of a vec2
|
||
*
|
||
* @param {vec2} out the receiving vector
|
||
* @param {vec2} a vector to floor
|
||
* @returns {vec2} out
|
||
*/
|
||
|
||
|
||
function floor(out, a) {
|
||
out[0] = Math.floor(a[0]);
|
||
out[1] = Math.floor(a[1]);
|
||
return out;
|
||
}
|
||
/**
|
||
* Returns the minimum of two vec2's
|
||
*
|
||
* @param {vec2} out the receiving vector
|
||
* @param {vec2} a the first operand
|
||
* @param {vec2} b the second operand
|
||
* @returns {vec2} out
|
||
*/
|
||
|
||
|
||
function min(out, a, b) {
|
||
out[0] = Math.min(a[0], b[0]);
|
||
out[1] = Math.min(a[1], b[1]);
|
||
return out;
|
||
}
|
||
/**
|
||
* Returns the maximum of two vec2's
|
||
*
|
||
* @param {vec2} out the receiving vector
|
||
* @param {vec2} a the first operand
|
||
* @param {vec2} b the second operand
|
||
* @returns {vec2} out
|
||
*/
|
||
|
||
|
||
function max(out, a, b) {
|
||
out[0] = Math.max(a[0], b[0]);
|
||
out[1] = Math.max(a[1], b[1]);
|
||
return out;
|
||
}
|
||
/**
|
||
* Math.round the components of a vec2
|
||
*
|
||
* @param {vec2} out the receiving vector
|
||
* @param {vec2} a vector to round
|
||
* @returns {vec2} out
|
||
*/
|
||
|
||
|
||
function round(out, a) {
|
||
out[0] = Math.round(a[0]);
|
||
out[1] = Math.round(a[1]);
|
||
return out;
|
||
}
|
||
/**
|
||
* Scales a vec2 by a scalar number
|
||
*
|
||
* @param {vec2} out the receiving vector
|
||
* @param {vec2} a the vector to scale
|
||
* @param {Number} b amount to scale the vector by
|
||
* @returns {vec2} out
|
||
*/
|
||
|
||
|
||
function scale(out, a, b) {
|
||
out[0] = a[0] * b;
|
||
out[1] = a[1] * b;
|
||
return out;
|
||
}
|
||
/**
|
||
* Adds two vec2's after scaling the second operand by a scalar value
|
||
*
|
||
* @param {vec2} out the receiving vector
|
||
* @param {vec2} a the first operand
|
||
* @param {vec2} b the second operand
|
||
* @param {Number} scale the amount to scale b by before adding
|
||
* @returns {vec2} out
|
||
*/
|
||
|
||
|
||
function scaleAndAdd(out, a, b, scale) {
|
||
out[0] = a[0] + b[0] * scale;
|
||
out[1] = a[1] + b[1] * scale;
|
||
return out;
|
||
}
|
||
/**
|
||
* Calculates the euclidian distance between two vec2's
|
||
*
|
||
* @param {vec2} a the first operand
|
||
* @param {vec2} b the second operand
|
||
* @returns {Number} distance between a and b
|
||
*/
|
||
|
||
|
||
function distance(a, b) {
|
||
var x = b[0] - a[0],
|
||
y = b[1] - a[1];
|
||
return Math.sqrt(x * x + y * y);
|
||
}
|
||
/**
|
||
* Calculates the squared euclidian distance between two vec2's
|
||
*
|
||
* @param {vec2} a the first operand
|
||
* @param {vec2} b the second operand
|
||
* @returns {Number} squared distance between a and b
|
||
*/
|
||
|
||
|
||
function squaredDistance(a, b) {
|
||
var x = b[0] - a[0],
|
||
y = b[1] - a[1];
|
||
return x * x + y * y;
|
||
}
|
||
/**
|
||
* Calculates the length of a vec2
|
||
*
|
||
* @param {vec2} a vector to calculate length of
|
||
* @returns {Number} length of a
|
||
*/
|
||
|
||
|
||
function length(a) {
|
||
var x = a[0],
|
||
y = a[1];
|
||
return Math.sqrt(x * x + y * y);
|
||
}
|
||
/**
|
||
* Calculates the squared length of a vec2
|
||
*
|
||
* @param {vec2} a vector to calculate squared length of
|
||
* @returns {Number} squared length of a
|
||
*/
|
||
|
||
|
||
function squaredLength(a) {
|
||
var x = a[0],
|
||
y = a[1];
|
||
return x * x + y * y;
|
||
}
|
||
/**
|
||
* Negates the components of a vec2
|
||
*
|
||
* @param {vec2} out the receiving vector
|
||
* @param {vec2} a vector to negate
|
||
* @returns {vec2} out
|
||
*/
|
||
|
||
|
||
function negate(out, a) {
|
||
out[0] = -a[0];
|
||
out[1] = -a[1];
|
||
return out;
|
||
}
|
||
/**
|
||
* Returns the inverse of the components of a vec2
|
||
*
|
||
* @param {vec2} out the receiving vector
|
||
* @param {vec2} a vector to invert
|
||
* @returns {vec2} out
|
||
*/
|
||
|
||
|
||
function inverse(out, a) {
|
||
out[0] = 1.0 / a[0];
|
||
out[1] = 1.0 / a[1];
|
||
return out;
|
||
}
|
||
/**
|
||
* Normalize a vec2
|
||
*
|
||
* @param {vec2} out the receiving vector
|
||
* @param {vec2} a vector to normalize
|
||
* @returns {vec2} out
|
||
*/
|
||
|
||
|
||
function normalize(out, a) {
|
||
var x = a[0],
|
||
y = a[1];
|
||
var len = x * x + y * y;
|
||
|
||
if (len > 0) {
|
||
//TODO: evaluate use of glm_invsqrt here?
|
||
len = 1 / Math.sqrt(len);
|
||
out[0] = a[0] * len;
|
||
out[1] = a[1] * len;
|
||
}
|
||
|
||
return out;
|
||
}
|
||
/**
|
||
* Calculates the dot product of two vec2's
|
||
*
|
||
* @param {vec2} a the first operand
|
||
* @param {vec2} b the second operand
|
||
* @returns {Number} dot product of a and b
|
||
*/
|
||
|
||
|
||
function dot(a, b) {
|
||
return a[0] * b[0] + a[1] * b[1];
|
||
}
|
||
/**
|
||
* Computes the cross product of two vec2's
|
||
* Note that the cross product must by definition produce a 3D vector
|
||
*
|
||
* @param {vec3} out the receiving vector
|
||
* @param {vec2} a the first operand
|
||
* @param {vec2} b the second operand
|
||
* @returns {vec3} out
|
||
*/
|
||
|
||
|
||
function cross(out, a, b) {
|
||
var z = a[0] * b[1] - a[1] * b[0];
|
||
out[0] = out[1] = 0;
|
||
out[2] = z;
|
||
return out;
|
||
}
|
||
/**
|
||
* Performs a linear interpolation between two vec2's
|
||
*
|
||
* @param {vec2} out the receiving vector
|
||
* @param {vec2} a the first operand
|
||
* @param {vec2} b the second operand
|
||
* @param {Number} t interpolation amount, in the range [0-1], between the two inputs
|
||
* @returns {vec2} out
|
||
*/
|
||
|
||
|
||
function lerp(out, a, b, t) {
|
||
var ax = a[0],
|
||
ay = a[1];
|
||
out[0] = ax + t * (b[0] - ax);
|
||
out[1] = ay + t * (b[1] - ay);
|
||
return out;
|
||
}
|
||
/**
|
||
* Generates a random vector with the given scale
|
||
*
|
||
* @param {vec2} out the receiving vector
|
||
* @param {Number} [scale] Length of the resulting vector. If ommitted, a unit vector will be returned
|
||
* @returns {vec2} out
|
||
*/
|
||
|
||
|
||
function random(out, scale) {
|
||
scale = scale || 1.0;
|
||
var r = glMatrix.RANDOM() * 2.0 * Math.PI;
|
||
out[0] = Math.cos(r) * scale;
|
||
out[1] = Math.sin(r) * scale;
|
||
return out;
|
||
}
|
||
/**
|
||
* Transforms the vec2 with a mat2
|
||
*
|
||
* @param {vec2} out the receiving vector
|
||
* @param {vec2} a the vector to transform
|
||
* @param {mat2} m matrix to transform with
|
||
* @returns {vec2} out
|
||
*/
|
||
|
||
|
||
function transformMat2(out, a, m) {
|
||
var x = a[0],
|
||
y = a[1];
|
||
out[0] = m[0] * x + m[2] * y;
|
||
out[1] = m[1] * x + m[3] * y;
|
||
return out;
|
||
}
|
||
/**
|
||
* Transforms the vec2 with a mat2d
|
||
*
|
||
* @param {vec2} out the receiving vector
|
||
* @param {vec2} a the vector to transform
|
||
* @param {mat2d} m matrix to transform with
|
||
* @returns {vec2} out
|
||
*/
|
||
|
||
|
||
function transformMat2d(out, a, m) {
|
||
var x = a[0],
|
||
y = a[1];
|
||
out[0] = m[0] * x + m[2] * y + m[4];
|
||
out[1] = m[1] * x + m[3] * y + m[5];
|
||
return out;
|
||
}
|
||
/**
|
||
* Transforms the vec2 with a mat3
|
||
* 3rd vector component is implicitly '1'
|
||
*
|
||
* @param {vec2} out the receiving vector
|
||
* @param {vec2} a the vector to transform
|
||
* @param {mat3} m matrix to transform with
|
||
* @returns {vec2} out
|
||
*/
|
||
|
||
|
||
function transformMat3(out, a, m) {
|
||
var x = a[0],
|
||
y = a[1];
|
||
out[0] = m[0] * x + m[3] * y + m[6];
|
||
out[1] = m[1] * x + m[4] * y + m[7];
|
||
return out;
|
||
}
|
||
/**
|
||
* Transforms the vec2 with a mat4
|
||
* 3rd vector component is implicitly '0'
|
||
* 4th vector component is implicitly '1'
|
||
*
|
||
* @param {vec2} out the receiving vector
|
||
* @param {vec2} a the vector to transform
|
||
* @param {mat4} m matrix to transform with
|
||
* @returns {vec2} out
|
||
*/
|
||
|
||
|
||
function transformMat4(out, a, m) {
|
||
var x = a[0];
|
||
var y = a[1];
|
||
out[0] = m[0] * x + m[4] * y + m[12];
|
||
out[1] = m[1] * x + m[5] * y + m[13];
|
||
return out;
|
||
}
|
||
/**
|
||
* Rotate a 2D vector
|
||
* @param {vec2} out The receiving vec2
|
||
* @param {vec2} a The vec2 point to rotate
|
||
* @param {vec2} b The origin of the rotation
|
||
* @param {Number} c The angle of rotation
|
||
* @returns {vec2} out
|
||
*/
|
||
|
||
|
||
function rotate(out, a, b, c) {
|
||
//Translate point to the origin
|
||
var p0 = a[0] - b[0],
|
||
p1 = a[1] - b[1],
|
||
sinC = Math.sin(c),
|
||
cosC = Math.cos(c); //perform rotation and translate to correct position
|
||
|
||
out[0] = p0 * cosC - p1 * sinC + b[0];
|
||
out[1] = p0 * sinC + p1 * cosC + b[1];
|
||
return out;
|
||
}
|
||
/**
|
||
* Get the angle between two 2D vectors
|
||
* @param {vec2} a The first operand
|
||
* @param {vec2} b The second operand
|
||
* @returns {Number} The angle in radians
|
||
*/
|
||
|
||
|
||
function angle(a, b) {
|
||
var x1 = a[0],
|
||
y1 = a[1],
|
||
x2 = b[0],
|
||
y2 = b[1];
|
||
var len1 = x1 * x1 + y1 * y1;
|
||
|
||
if (len1 > 0) {
|
||
//TODO: evaluate use of glm_invsqrt here?
|
||
len1 = 1 / Math.sqrt(len1);
|
||
}
|
||
|
||
var len2 = x2 * x2 + y2 * y2;
|
||
|
||
if (len2 > 0) {
|
||
//TODO: evaluate use of glm_invsqrt here?
|
||
len2 = 1 / Math.sqrt(len2);
|
||
}
|
||
|
||
var cosine = (x1 * x2 + y1 * y2) * len1 * len2;
|
||
|
||
if (cosine > 1.0) {
|
||
return 0;
|
||
} else if (cosine < -1.0) {
|
||
return Math.PI;
|
||
} else {
|
||
return Math.acos(cosine);
|
||
}
|
||
}
|
||
/**
|
||
* Returns a string representation of a vector
|
||
*
|
||
* @param {vec2} a vector to represent as a string
|
||
* @returns {String} string representation of the vector
|
||
*/
|
||
|
||
|
||
function str(a) {
|
||
return 'vec2(' + a[0] + ', ' + a[1] + ')';
|
||
}
|
||
/**
|
||
* Returns whether or not the vectors exactly have the same elements in the same position (when compared with ===)
|
||
*
|
||
* @param {vec2} a The first vector.
|
||
* @param {vec2} b The second vector.
|
||
* @returns {Boolean} True if the vectors are equal, false otherwise.
|
||
*/
|
||
|
||
|
||
function exactEquals(a, b) {
|
||
return a[0] === b[0] && a[1] === b[1];
|
||
}
|
||
/**
|
||
* Returns whether or not the vectors have approximately the same elements in the same position.
|
||
*
|
||
* @param {vec2} a The first vector.
|
||
* @param {vec2} b The second vector.
|
||
* @returns {Boolean} True if the vectors are equal, false otherwise.
|
||
*/
|
||
|
||
|
||
function equals(a, b) {
|
||
var a0 = a[0],
|
||
a1 = a[1];
|
||
var b0 = b[0],
|
||
b1 = b[1];
|
||
return Math.abs(a0 - b0) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a0), Math.abs(b0)) && Math.abs(a1 - b1) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a1), Math.abs(b1));
|
||
}
|
||
/**
|
||
* Alias for {@link vec2.length}
|
||
* @function
|
||
*/
|
||
|
||
|
||
var len = exports.len = length;
|
||
/**
|
||
* Alias for {@link vec2.subtract}
|
||
* @function
|
||
*/
|
||
|
||
var sub = exports.sub = subtract;
|
||
/**
|
||
* Alias for {@link vec2.multiply}
|
||
* @function
|
||
*/
|
||
|
||
var mul = exports.mul = multiply;
|
||
/**
|
||
* Alias for {@link vec2.divide}
|
||
* @function
|
||
*/
|
||
|
||
var div = exports.div = divide;
|
||
/**
|
||
* Alias for {@link vec2.distance}
|
||
* @function
|
||
*/
|
||
|
||
var dist = exports.dist = distance;
|
||
/**
|
||
* Alias for {@link vec2.squaredDistance}
|
||
* @function
|
||
*/
|
||
|
||
var sqrDist = exports.sqrDist = squaredDistance;
|
||
/**
|
||
* Alias for {@link vec2.squaredLength}
|
||
* @function
|
||
*/
|
||
|
||
var sqrLen = exports.sqrLen = squaredLength;
|
||
/**
|
||
* Perform some operation over an array of vec2s.
|
||
*
|
||
* @param {Array} a the array of vectors to iterate over
|
||
* @param {Number} stride Number of elements between the start of each vec2. If 0 assumes tightly packed
|
||
* @param {Number} offset Number of elements to skip at the beginning of the array
|
||
* @param {Number} count Number of vec2s to iterate over. If 0 iterates over entire array
|
||
* @param {Function} fn Function to call for each vector in the array
|
||
* @param {Object} [arg] additional argument to pass to fn
|
||
* @returns {Array} a
|
||
* @function
|
||
*/
|
||
|
||
var forEach = exports.forEach = function () {
|
||
var vec = create();
|
||
return function (a, stride, offset, count, fn, arg) {
|
||
var i = void 0,
|
||
l = void 0;
|
||
|
||
if (!stride) {
|
||
stride = 2;
|
||
}
|
||
|
||
if (!offset) {
|
||
offset = 0;
|
||
}
|
||
|
||
if (count) {
|
||
l = Math.min(count * stride + offset, a.length);
|
||
} else {
|
||
l = a.length;
|
||
}
|
||
|
||
for (i = offset; i < l; i += stride) {
|
||
vec[0] = a[i];
|
||
vec[1] = a[i + 1];
|
||
fn(vec, vec, arg);
|
||
a[i] = vec[0];
|
||
a[i + 1] = vec[1];
|
||
}
|
||
|
||
return a;
|
||
};
|
||
}();
|
||
|
||
/***/ }),
|
||
/* 11 */
|
||
/***/ (function(module, exports) {
|
||
|
||
var clamp = function clamp(a, min, max) {
|
||
if (a < min) {
|
||
return min;
|
||
} else if (a > max) {
|
||
return max;
|
||
}
|
||
|
||
return a;
|
||
};
|
||
|
||
module.exports = clamp;
|
||
|
||
/***/ }),
|
||
/* 12 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
var vec3 = __webpack_require__(13);
|
||
|
||
module.exports = vec3;
|
||
|
||
/***/ }),
|
||
/* 13 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
|
||
Object.defineProperty(exports, "__esModule", {
|
||
value: true
|
||
});
|
||
exports.forEach = exports.sqrLen = exports.len = exports.sqrDist = exports.dist = exports.div = exports.mul = exports.sub = undefined;
|
||
exports.create = create;
|
||
exports.clone = clone;
|
||
exports.length = length;
|
||
exports.fromValues = fromValues;
|
||
exports.copy = copy;
|
||
exports.set = set;
|
||
exports.add = add;
|
||
exports.subtract = subtract;
|
||
exports.multiply = multiply;
|
||
exports.divide = divide;
|
||
exports.ceil = ceil;
|
||
exports.floor = floor;
|
||
exports.min = min;
|
||
exports.max = max;
|
||
exports.round = round;
|
||
exports.scale = scale;
|
||
exports.scaleAndAdd = scaleAndAdd;
|
||
exports.distance = distance;
|
||
exports.squaredDistance = squaredDistance;
|
||
exports.squaredLength = squaredLength;
|
||
exports.negate = negate;
|
||
exports.inverse = inverse;
|
||
exports.normalize = normalize;
|
||
exports.dot = dot;
|
||
exports.cross = cross;
|
||
exports.lerp = lerp;
|
||
exports.hermite = hermite;
|
||
exports.bezier = bezier;
|
||
exports.random = random;
|
||
exports.transformMat4 = transformMat4;
|
||
exports.transformMat3 = transformMat3;
|
||
exports.transformQuat = transformQuat;
|
||
exports.rotateX = rotateX;
|
||
exports.rotateY = rotateY;
|
||
exports.rotateZ = rotateZ;
|
||
exports.angle = angle;
|
||
exports.str = str;
|
||
exports.exactEquals = exactEquals;
|
||
exports.equals = equals;
|
||
|
||
var _common = __webpack_require__(3);
|
||
|
||
var glMatrix = _interopRequireWildcard(_common);
|
||
|
||
function _interopRequireWildcard(obj) {
|
||
if (obj && obj.__esModule) {
|
||
return obj;
|
||
} else {
|
||
var newObj = {};
|
||
|
||
if (obj != null) {
|
||
for (var key in obj) {
|
||
if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key];
|
||
}
|
||
}
|
||
|
||
newObj.default = obj;
|
||
return newObj;
|
||
}
|
||
}
|
||
/**
|
||
* 3 Dimensional Vector
|
||
* @module vec3
|
||
*/
|
||
|
||
/**
|
||
* Creates a new, empty vec3
|
||
*
|
||
* @returns {vec3} a new 3D vector
|
||
*/
|
||
|
||
|
||
function create() {
|
||
var out = new glMatrix.ARRAY_TYPE(3);
|
||
|
||
if (glMatrix.ARRAY_TYPE != Float32Array) {
|
||
out[0] = 0;
|
||
out[1] = 0;
|
||
out[2] = 0;
|
||
}
|
||
|
||
return out;
|
||
}
|
||
/**
|
||
* Creates a new vec3 initialized with values from an existing vector
|
||
*
|
||
* @param {vec3} a vector to clone
|
||
* @returns {vec3} a new 3D vector
|
||
*/
|
||
|
||
|
||
function clone(a) {
|
||
var out = new glMatrix.ARRAY_TYPE(3);
|
||
out[0] = a[0];
|
||
out[1] = a[1];
|
||
out[2] = a[2];
|
||
return out;
|
||
}
|
||
/**
|
||
* Calculates the length of a vec3
|
||
*
|
||
* @param {vec3} a vector to calculate length of
|
||
* @returns {Number} length of a
|
||
*/
|
||
|
||
|
||
function length(a) {
|
||
var x = a[0];
|
||
var y = a[1];
|
||
var z = a[2];
|
||
return Math.sqrt(x * x + y * y + z * z);
|
||
}
|
||
/**
|
||
* Creates a new vec3 initialized with the given values
|
||
*
|
||
* @param {Number} x X component
|
||
* @param {Number} y Y component
|
||
* @param {Number} z Z component
|
||
* @returns {vec3} a new 3D vector
|
||
*/
|
||
|
||
|
||
function fromValues(x, y, z) {
|
||
var out = new glMatrix.ARRAY_TYPE(3);
|
||
out[0] = x;
|
||
out[1] = y;
|
||
out[2] = z;
|
||
return out;
|
||
}
|
||
/**
|
||
* Copy the values from one vec3 to another
|
||
*
|
||
* @param {vec3} out the receiving vector
|
||
* @param {vec3} a the source vector
|
||
* @returns {vec3} out
|
||
*/
|
||
|
||
|
||
function copy(out, a) {
|
||
out[0] = a[0];
|
||
out[1] = a[1];
|
||
out[2] = a[2];
|
||
return out;
|
||
}
|
||
/**
|
||
* Set the components of a vec3 to the given values
|
||
*
|
||
* @param {vec3} out the receiving vector
|
||
* @param {Number} x X component
|
||
* @param {Number} y Y component
|
||
* @param {Number} z Z component
|
||
* @returns {vec3} out
|
||
*/
|
||
|
||
|
||
function set(out, x, y, z) {
|
||
out[0] = x;
|
||
out[1] = y;
|
||
out[2] = z;
|
||
return out;
|
||
}
|
||
/**
|
||
* Adds two vec3's
|
||
*
|
||
* @param {vec3} out the receiving vector
|
||
* @param {vec3} a the first operand
|
||
* @param {vec3} b the second operand
|
||
* @returns {vec3} out
|
||
*/
|
||
|
||
|
||
function add(out, a, b) {
|
||
out[0] = a[0] + b[0];
|
||
out[1] = a[1] + b[1];
|
||
out[2] = a[2] + b[2];
|
||
return out;
|
||
}
|
||
/**
|
||
* Subtracts vector b from vector a
|
||
*
|
||
* @param {vec3} out the receiving vector
|
||
* @param {vec3} a the first operand
|
||
* @param {vec3} b the second operand
|
||
* @returns {vec3} out
|
||
*/
|
||
|
||
|
||
function subtract(out, a, b) {
|
||
out[0] = a[0] - b[0];
|
||
out[1] = a[1] - b[1];
|
||
out[2] = a[2] - b[2];
|
||
return out;
|
||
}
|
||
/**
|
||
* Multiplies two vec3's
|
||
*
|
||
* @param {vec3} out the receiving vector
|
||
* @param {vec3} a the first operand
|
||
* @param {vec3} b the second operand
|
||
* @returns {vec3} out
|
||
*/
|
||
|
||
|
||
function multiply(out, a, b) {
|
||
out[0] = a[0] * b[0];
|
||
out[1] = a[1] * b[1];
|
||
out[2] = a[2] * b[2];
|
||
return out;
|
||
}
|
||
/**
|
||
* Divides two vec3's
|
||
*
|
||
* @param {vec3} out the receiving vector
|
||
* @param {vec3} a the first operand
|
||
* @param {vec3} b the second operand
|
||
* @returns {vec3} out
|
||
*/
|
||
|
||
|
||
function divide(out, a, b) {
|
||
out[0] = a[0] / b[0];
|
||
out[1] = a[1] / b[1];
|
||
out[2] = a[2] / b[2];
|
||
return out;
|
||
}
|
||
/**
|
||
* Math.ceil the components of a vec3
|
||
*
|
||
* @param {vec3} out the receiving vector
|
||
* @param {vec3} a vector to ceil
|
||
* @returns {vec3} out
|
||
*/
|
||
|
||
|
||
function ceil(out, a) {
|
||
out[0] = Math.ceil(a[0]);
|
||
out[1] = Math.ceil(a[1]);
|
||
out[2] = Math.ceil(a[2]);
|
||
return out;
|
||
}
|
||
/**
|
||
* Math.floor the components of a vec3
|
||
*
|
||
* @param {vec3} out the receiving vector
|
||
* @param {vec3} a vector to floor
|
||
* @returns {vec3} out
|
||
*/
|
||
|
||
|
||
function floor(out, a) {
|
||
out[0] = Math.floor(a[0]);
|
||
out[1] = Math.floor(a[1]);
|
||
out[2] = Math.floor(a[2]);
|
||
return out;
|
||
}
|
||
/**
|
||
* Returns the minimum of two vec3's
|
||
*
|
||
* @param {vec3} out the receiving vector
|
||
* @param {vec3} a the first operand
|
||
* @param {vec3} b the second operand
|
||
* @returns {vec3} out
|
||
*/
|
||
|
||
|
||
function min(out, a, b) {
|
||
out[0] = Math.min(a[0], b[0]);
|
||
out[1] = Math.min(a[1], b[1]);
|
||
out[2] = Math.min(a[2], b[2]);
|
||
return out;
|
||
}
|
||
/**
|
||
* Returns the maximum of two vec3's
|
||
*
|
||
* @param {vec3} out the receiving vector
|
||
* @param {vec3} a the first operand
|
||
* @param {vec3} b the second operand
|
||
* @returns {vec3} out
|
||
*/
|
||
|
||
|
||
function max(out, a, b) {
|
||
out[0] = Math.max(a[0], b[0]);
|
||
out[1] = Math.max(a[1], b[1]);
|
||
out[2] = Math.max(a[2], b[2]);
|
||
return out;
|
||
}
|
||
/**
|
||
* Math.round the components of a vec3
|
||
*
|
||
* @param {vec3} out the receiving vector
|
||
* @param {vec3} a vector to round
|
||
* @returns {vec3} out
|
||
*/
|
||
|
||
|
||
function round(out, a) {
|
||
out[0] = Math.round(a[0]);
|
||
out[1] = Math.round(a[1]);
|
||
out[2] = Math.round(a[2]);
|
||
return out;
|
||
}
|
||
/**
|
||
* Scales a vec3 by a scalar number
|
||
*
|
||
* @param {vec3} out the receiving vector
|
||
* @param {vec3} a the vector to scale
|
||
* @param {Number} b amount to scale the vector by
|
||
* @returns {vec3} out
|
||
*/
|
||
|
||
|
||
function scale(out, a, b) {
|
||
out[0] = a[0] * b;
|
||
out[1] = a[1] * b;
|
||
out[2] = a[2] * b;
|
||
return out;
|
||
}
|
||
/**
|
||
* Adds two vec3's after scaling the second operand by a scalar value
|
||
*
|
||
* @param {vec3} out the receiving vector
|
||
* @param {vec3} a the first operand
|
||
* @param {vec3} b the second operand
|
||
* @param {Number} scale the amount to scale b by before adding
|
||
* @returns {vec3} out
|
||
*/
|
||
|
||
|
||
function scaleAndAdd(out, a, b, scale) {
|
||
out[0] = a[0] + b[0] * scale;
|
||
out[1] = a[1] + b[1] * scale;
|
||
out[2] = a[2] + b[2] * scale;
|
||
return out;
|
||
}
|
||
/**
|
||
* Calculates the euclidian distance between two vec3's
|
||
*
|
||
* @param {vec3} a the first operand
|
||
* @param {vec3} b the second operand
|
||
* @returns {Number} distance between a and b
|
||
*/
|
||
|
||
|
||
function distance(a, b) {
|
||
var x = b[0] - a[0];
|
||
var y = b[1] - a[1];
|
||
var z = b[2] - a[2];
|
||
return Math.sqrt(x * x + y * y + z * z);
|
||
}
|
||
/**
|
||
* Calculates the squared euclidian distance between two vec3's
|
||
*
|
||
* @param {vec3} a the first operand
|
||
* @param {vec3} b the second operand
|
||
* @returns {Number} squared distance between a and b
|
||
*/
|
||
|
||
|
||
function squaredDistance(a, b) {
|
||
var x = b[0] - a[0];
|
||
var y = b[1] - a[1];
|
||
var z = b[2] - a[2];
|
||
return x * x + y * y + z * z;
|
||
}
|
||
/**
|
||
* Calculates the squared length of a vec3
|
||
*
|
||
* @param {vec3} a vector to calculate squared length of
|
||
* @returns {Number} squared length of a
|
||
*/
|
||
|
||
|
||
function squaredLength(a) {
|
||
var x = a[0];
|
||
var y = a[1];
|
||
var z = a[2];
|
||
return x * x + y * y + z * z;
|
||
}
|
||
/**
|
||
* Negates the components of a vec3
|
||
*
|
||
* @param {vec3} out the receiving vector
|
||
* @param {vec3} a vector to negate
|
||
* @returns {vec3} out
|
||
*/
|
||
|
||
|
||
function negate(out, a) {
|
||
out[0] = -a[0];
|
||
out[1] = -a[1];
|
||
out[2] = -a[2];
|
||
return out;
|
||
}
|
||
/**
|
||
* Returns the inverse of the components of a vec3
|
||
*
|
||
* @param {vec3} out the receiving vector
|
||
* @param {vec3} a vector to invert
|
||
* @returns {vec3} out
|
||
*/
|
||
|
||
|
||
function inverse(out, a) {
|
||
out[0] = 1.0 / a[0];
|
||
out[1] = 1.0 / a[1];
|
||
out[2] = 1.0 / a[2];
|
||
return out;
|
||
}
|
||
/**
|
||
* Normalize a vec3
|
||
*
|
||
* @param {vec3} out the receiving vector
|
||
* @param {vec3} a vector to normalize
|
||
* @returns {vec3} out
|
||
*/
|
||
|
||
|
||
function normalize(out, a) {
|
||
var x = a[0];
|
||
var y = a[1];
|
||
var z = a[2];
|
||
var len = x * x + y * y + z * z;
|
||
|
||
if (len > 0) {
|
||
//TODO: evaluate use of glm_invsqrt here?
|
||
len = 1 / Math.sqrt(len);
|
||
out[0] = a[0] * len;
|
||
out[1] = a[1] * len;
|
||
out[2] = a[2] * len;
|
||
}
|
||
|
||
return out;
|
||
}
|
||
/**
|
||
* Calculates the dot product of two vec3's
|
||
*
|
||
* @param {vec3} a the first operand
|
||
* @param {vec3} b the second operand
|
||
* @returns {Number} dot product of a and b
|
||
*/
|
||
|
||
|
||
function dot(a, b) {
|
||
return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
|
||
}
|
||
/**
|
||
* Computes the cross product of two vec3's
|
||
*
|
||
* @param {vec3} out the receiving vector
|
||
* @param {vec3} a the first operand
|
||
* @param {vec3} b the second operand
|
||
* @returns {vec3} out
|
||
*/
|
||
|
||
|
||
function cross(out, a, b) {
|
||
var ax = a[0],
|
||
ay = a[1],
|
||
az = a[2];
|
||
var bx = b[0],
|
||
by = b[1],
|
||
bz = b[2];
|
||
out[0] = ay * bz - az * by;
|
||
out[1] = az * bx - ax * bz;
|
||
out[2] = ax * by - ay * bx;
|
||
return out;
|
||
}
|
||
/**
|
||
* Performs a linear interpolation between two vec3's
|
||
*
|
||
* @param {vec3} out the receiving vector
|
||
* @param {vec3} a the first operand
|
||
* @param {vec3} b the second operand
|
||
* @param {Number} t interpolation amount, in the range [0-1], between the two inputs
|
||
* @returns {vec3} out
|
||
*/
|
||
|
||
|
||
function lerp(out, a, b, t) {
|
||
var ax = a[0];
|
||
var ay = a[1];
|
||
var az = a[2];
|
||
out[0] = ax + t * (b[0] - ax);
|
||
out[1] = ay + t * (b[1] - ay);
|
||
out[2] = az + t * (b[2] - az);
|
||
return out;
|
||
}
|
||
/**
|
||
* Performs a hermite interpolation with two control points
|
||
*
|
||
* @param {vec3} out the receiving vector
|
||
* @param {vec3} a the first operand
|
||
* @param {vec3} b the second operand
|
||
* @param {vec3} c the third operand
|
||
* @param {vec3} d the fourth operand
|
||
* @param {Number} t interpolation amount, in the range [0-1], between the two inputs
|
||
* @returns {vec3} out
|
||
*/
|
||
|
||
|
||
function hermite(out, a, b, c, d, t) {
|
||
var factorTimes2 = t * t;
|
||
var factor1 = factorTimes2 * (2 * t - 3) + 1;
|
||
var factor2 = factorTimes2 * (t - 2) + t;
|
||
var factor3 = factorTimes2 * (t - 1);
|
||
var factor4 = factorTimes2 * (3 - 2 * t);
|
||
out[0] = a[0] * factor1 + b[0] * factor2 + c[0] * factor3 + d[0] * factor4;
|
||
out[1] = a[1] * factor1 + b[1] * factor2 + c[1] * factor3 + d[1] * factor4;
|
||
out[2] = a[2] * factor1 + b[2] * factor2 + c[2] * factor3 + d[2] * factor4;
|
||
return out;
|
||
}
|
||
/**
|
||
* Performs a bezier interpolation with two control points
|
||
*
|
||
* @param {vec3} out the receiving vector
|
||
* @param {vec3} a the first operand
|
||
* @param {vec3} b the second operand
|
||
* @param {vec3} c the third operand
|
||
* @param {vec3} d the fourth operand
|
||
* @param {Number} t interpolation amount, in the range [0-1], between the two inputs
|
||
* @returns {vec3} out
|
||
*/
|
||
|
||
|
||
function bezier(out, a, b, c, d, t) {
|
||
var inverseFactor = 1 - t;
|
||
var inverseFactorTimesTwo = inverseFactor * inverseFactor;
|
||
var factorTimes2 = t * t;
|
||
var factor1 = inverseFactorTimesTwo * inverseFactor;
|
||
var factor2 = 3 * t * inverseFactorTimesTwo;
|
||
var factor3 = 3 * factorTimes2 * inverseFactor;
|
||
var factor4 = factorTimes2 * t;
|
||
out[0] = a[0] * factor1 + b[0] * factor2 + c[0] * factor3 + d[0] * factor4;
|
||
out[1] = a[1] * factor1 + b[1] * factor2 + c[1] * factor3 + d[1] * factor4;
|
||
out[2] = a[2] * factor1 + b[2] * factor2 + c[2] * factor3 + d[2] * factor4;
|
||
return out;
|
||
}
|
||
/**
|
||
* Generates a random vector with the given scale
|
||
*
|
||
* @param {vec3} out the receiving vector
|
||
* @param {Number} [scale] Length of the resulting vector. If ommitted, a unit vector will be returned
|
||
* @returns {vec3} out
|
||
*/
|
||
|
||
|
||
function random(out, scale) {
|
||
scale = scale || 1.0;
|
||
var r = glMatrix.RANDOM() * 2.0 * Math.PI;
|
||
var z = glMatrix.RANDOM() * 2.0 - 1.0;
|
||
var zScale = Math.sqrt(1.0 - z * z) * scale;
|
||
out[0] = Math.cos(r) * zScale;
|
||
out[1] = Math.sin(r) * zScale;
|
||
out[2] = z * scale;
|
||
return out;
|
||
}
|
||
/**
|
||
* Transforms the vec3 with a mat4.
|
||
* 4th vector component is implicitly '1'
|
||
*
|
||
* @param {vec3} out the receiving vector
|
||
* @param {vec3} a the vector to transform
|
||
* @param {mat4} m matrix to transform with
|
||
* @returns {vec3} out
|
||
*/
|
||
|
||
|
||
function transformMat4(out, a, m) {
|
||
var x = a[0],
|
||
y = a[1],
|
||
z = a[2];
|
||
var w = m[3] * x + m[7] * y + m[11] * z + m[15];
|
||
w = w || 1.0;
|
||
out[0] = (m[0] * x + m[4] * y + m[8] * z + m[12]) / w;
|
||
out[1] = (m[1] * x + m[5] * y + m[9] * z + m[13]) / w;
|
||
out[2] = (m[2] * x + m[6] * y + m[10] * z + m[14]) / w;
|
||
return out;
|
||
}
|
||
/**
|
||
* Transforms the vec3 with a mat3.
|
||
*
|
||
* @param {vec3} out the receiving vector
|
||
* @param {vec3} a the vector to transform
|
||
* @param {mat3} m the 3x3 matrix to transform with
|
||
* @returns {vec3} out
|
||
*/
|
||
|
||
|
||
function transformMat3(out, a, m) {
|
||
var x = a[0],
|
||
y = a[1],
|
||
z = a[2];
|
||
out[0] = x * m[0] + y * m[3] + z * m[6];
|
||
out[1] = x * m[1] + y * m[4] + z * m[7];
|
||
out[2] = x * m[2] + y * m[5] + z * m[8];
|
||
return out;
|
||
}
|
||
/**
|
||
* Transforms the vec3 with a quat
|
||
* Can also be used for dual quaternions. (Multiply it with the real part)
|
||
*
|
||
* @param {vec3} out the receiving vector
|
||
* @param {vec3} a the vector to transform
|
||
* @param {quat} q quaternion to transform with
|
||
* @returns {vec3} out
|
||
*/
|
||
|
||
|
||
function transformQuat(out, a, q) {
|
||
// benchmarks: https://jsperf.com/quaternion-transform-vec3-implementations-fixed
|
||
var qx = q[0],
|
||
qy = q[1],
|
||
qz = q[2],
|
||
qw = q[3];
|
||
var x = a[0],
|
||
y = a[1],
|
||
z = a[2]; // var qvec = [qx, qy, qz];
|
||
// var uv = vec3.cross([], qvec, a);
|
||
|
||
var uvx = qy * z - qz * y,
|
||
uvy = qz * x - qx * z,
|
||
uvz = qx * y - qy * x; // var uuv = vec3.cross([], qvec, uv);
|
||
|
||
var uuvx = qy * uvz - qz * uvy,
|
||
uuvy = qz * uvx - qx * uvz,
|
||
uuvz = qx * uvy - qy * uvx; // vec3.scale(uv, uv, 2 * w);
|
||
|
||
var w2 = qw * 2;
|
||
uvx *= w2;
|
||
uvy *= w2;
|
||
uvz *= w2; // vec3.scale(uuv, uuv, 2);
|
||
|
||
uuvx *= 2;
|
||
uuvy *= 2;
|
||
uuvz *= 2; // return vec3.add(out, a, vec3.add(out, uv, uuv));
|
||
|
||
out[0] = x + uvx + uuvx;
|
||
out[1] = y + uvy + uuvy;
|
||
out[2] = z + uvz + uuvz;
|
||
return out;
|
||
}
|
||
/**
|
||
* Rotate a 3D vector around the x-axis
|
||
* @param {vec3} out The receiving vec3
|
||
* @param {vec3} a The vec3 point to rotate
|
||
* @param {vec3} b The origin of the rotation
|
||
* @param {Number} c The angle of rotation
|
||
* @returns {vec3} out
|
||
*/
|
||
|
||
|
||
function rotateX(out, a, b, c) {
|
||
var p = [],
|
||
r = []; //Translate point to the origin
|
||
|
||
p[0] = a[0] - b[0];
|
||
p[1] = a[1] - b[1];
|
||
p[2] = a[2] - b[2]; //perform rotation
|
||
|
||
r[0] = p[0];
|
||
r[1] = p[1] * Math.cos(c) - p[2] * Math.sin(c);
|
||
r[2] = p[1] * Math.sin(c) + p[2] * Math.cos(c); //translate to correct position
|
||
|
||
out[0] = r[0] + b[0];
|
||
out[1] = r[1] + b[1];
|
||
out[2] = r[2] + b[2];
|
||
return out;
|
||
}
|
||
/**
|
||
* Rotate a 3D vector around the y-axis
|
||
* @param {vec3} out The receiving vec3
|
||
* @param {vec3} a The vec3 point to rotate
|
||
* @param {vec3} b The origin of the rotation
|
||
* @param {Number} c The angle of rotation
|
||
* @returns {vec3} out
|
||
*/
|
||
|
||
|
||
function rotateY(out, a, b, c) {
|
||
var p = [],
|
||
r = []; //Translate point to the origin
|
||
|
||
p[0] = a[0] - b[0];
|
||
p[1] = a[1] - b[1];
|
||
p[2] = a[2] - b[2]; //perform rotation
|
||
|
||
r[0] = p[2] * Math.sin(c) + p[0] * Math.cos(c);
|
||
r[1] = p[1];
|
||
r[2] = p[2] * Math.cos(c) - p[0] * Math.sin(c); //translate to correct position
|
||
|
||
out[0] = r[0] + b[0];
|
||
out[1] = r[1] + b[1];
|
||
out[2] = r[2] + b[2];
|
||
return out;
|
||
}
|
||
/**
|
||
* Rotate a 3D vector around the z-axis
|
||
* @param {vec3} out The receiving vec3
|
||
* @param {vec3} a The vec3 point to rotate
|
||
* @param {vec3} b The origin of the rotation
|
||
* @param {Number} c The angle of rotation
|
||
* @returns {vec3} out
|
||
*/
|
||
|
||
|
||
function rotateZ(out, a, b, c) {
|
||
var p = [],
|
||
r = []; //Translate point to the origin
|
||
|
||
p[0] = a[0] - b[0];
|
||
p[1] = a[1] - b[1];
|
||
p[2] = a[2] - b[2]; //perform rotation
|
||
|
||
r[0] = p[0] * Math.cos(c) - p[1] * Math.sin(c);
|
||
r[1] = p[0] * Math.sin(c) + p[1] * Math.cos(c);
|
||
r[2] = p[2]; //translate to correct position
|
||
|
||
out[0] = r[0] + b[0];
|
||
out[1] = r[1] + b[1];
|
||
out[2] = r[2] + b[2];
|
||
return out;
|
||
}
|
||
/**
|
||
* Get the angle between two 3D vectors
|
||
* @param {vec3} a The first operand
|
||
* @param {vec3} b The second operand
|
||
* @returns {Number} The angle in radians
|
||
*/
|
||
|
||
|
||
function angle(a, b) {
|
||
var tempA = fromValues(a[0], a[1], a[2]);
|
||
var tempB = fromValues(b[0], b[1], b[2]);
|
||
normalize(tempA, tempA);
|
||
normalize(tempB, tempB);
|
||
var cosine = dot(tempA, tempB);
|
||
|
||
if (cosine > 1.0) {
|
||
return 0;
|
||
} else if (cosine < -1.0) {
|
||
return Math.PI;
|
||
} else {
|
||
return Math.acos(cosine);
|
||
}
|
||
}
|
||
/**
|
||
* Returns a string representation of a vector
|
||
*
|
||
* @param {vec3} a vector to represent as a string
|
||
* @returns {String} string representation of the vector
|
||
*/
|
||
|
||
|
||
function str(a) {
|
||
return 'vec3(' + a[0] + ', ' + a[1] + ', ' + a[2] + ')';
|
||
}
|
||
/**
|
||
* Returns whether or not the vectors have exactly the same elements in the same position (when compared with ===)
|
||
*
|
||
* @param {vec3} a The first vector.
|
||
* @param {vec3} b The second vector.
|
||
* @returns {Boolean} True if the vectors are equal, false otherwise.
|
||
*/
|
||
|
||
|
||
function exactEquals(a, b) {
|
||
return a[0] === b[0] && a[1] === b[1] && a[2] === b[2];
|
||
}
|
||
/**
|
||
* Returns whether or not the vectors have approximately the same elements in the same position.
|
||
*
|
||
* @param {vec3} a The first vector.
|
||
* @param {vec3} b The second vector.
|
||
* @returns {Boolean} True if the vectors are equal, false otherwise.
|
||
*/
|
||
|
||
|
||
function equals(a, b) {
|
||
var a0 = a[0],
|
||
a1 = a[1],
|
||
a2 = a[2];
|
||
var b0 = b[0],
|
||
b1 = b[1],
|
||
b2 = b[2];
|
||
return Math.abs(a0 - b0) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a0), Math.abs(b0)) && Math.abs(a1 - b1) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a1), Math.abs(b1)) && Math.abs(a2 - b2) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a2), Math.abs(b2));
|
||
}
|
||
/**
|
||
* Alias for {@link vec3.subtract}
|
||
* @function
|
||
*/
|
||
|
||
|
||
var sub = exports.sub = subtract;
|
||
/**
|
||
* Alias for {@link vec3.multiply}
|
||
* @function
|
||
*/
|
||
|
||
var mul = exports.mul = multiply;
|
||
/**
|
||
* Alias for {@link vec3.divide}
|
||
* @function
|
||
*/
|
||
|
||
var div = exports.div = divide;
|
||
/**
|
||
* Alias for {@link vec3.distance}
|
||
* @function
|
||
*/
|
||
|
||
var dist = exports.dist = distance;
|
||
/**
|
||
* Alias for {@link vec3.squaredDistance}
|
||
* @function
|
||
*/
|
||
|
||
var sqrDist = exports.sqrDist = squaredDistance;
|
||
/**
|
||
* Alias for {@link vec3.length}
|
||
* @function
|
||
*/
|
||
|
||
var len = exports.len = length;
|
||
/**
|
||
* Alias for {@link vec3.squaredLength}
|
||
* @function
|
||
*/
|
||
|
||
var sqrLen = exports.sqrLen = squaredLength;
|
||
/**
|
||
* Perform some operation over an array of vec3s.
|
||
*
|
||
* @param {Array} a the array of vectors to iterate over
|
||
* @param {Number} stride Number of elements between the start of each vec3. If 0 assumes tightly packed
|
||
* @param {Number} offset Number of elements to skip at the beginning of the array
|
||
* @param {Number} count Number of vec3s to iterate over. If 0 iterates over entire array
|
||
* @param {Function} fn Function to call for each vector in the array
|
||
* @param {Object} [arg] additional argument to pass to fn
|
||
* @returns {Array} a
|
||
* @function
|
||
*/
|
||
|
||
var forEach = exports.forEach = function () {
|
||
var vec = create();
|
||
return function (a, stride, offset, count, fn, arg) {
|
||
var i = void 0,
|
||
l = void 0;
|
||
|
||
if (!stride) {
|
||
stride = 3;
|
||
}
|
||
|
||
if (!offset) {
|
||
offset = 0;
|
||
}
|
||
|
||
if (count) {
|
||
l = Math.min(count * stride + offset, a.length);
|
||
} else {
|
||
l = a.length;
|
||
}
|
||
|
||
for (i = offset; i < l; i += stride) {
|
||
vec[0] = a[i];
|
||
vec[1] = a[i + 1];
|
||
vec[2] = a[i + 2];
|
||
fn(vec, vec, arg);
|
||
a[i] = vec[0];
|
||
a[i + 1] = vec[1];
|
||
a[i + 2] = vec[2];
|
||
}
|
||
|
||
return a;
|
||
};
|
||
}();
|
||
|
||
/***/ }),
|
||
/* 14 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
var clone = __webpack_require__(15);
|
||
|
||
var each = __webpack_require__(17);
|
||
|
||
var mat3 = __webpack_require__(4);
|
||
|
||
module.exports = function transform(m, ts) {
|
||
m = clone(m);
|
||
each(ts, function (t) {
|
||
switch (t[0]) {
|
||
case 't':
|
||
mat3.translate(m, m, [t[1], t[2]]);
|
||
break;
|
||
|
||
case 's':
|
||
mat3.scale(m, m, [t[1], t[2]]);
|
||
break;
|
||
|
||
case 'r':
|
||
mat3.rotate(m, m, t[1]);
|
||
break;
|
||
|
||
case 'm':
|
||
mat3.multiply(m, m, t[1]);
|
||
break;
|
||
|
||
default:
|
||
return false;
|
||
}
|
||
});
|
||
return m;
|
||
};
|
||
|
||
/***/ }),
|
||
/* 15 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) {
|
||
return typeof obj;
|
||
} : function (obj) {
|
||
return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
|
||
};
|
||
|
||
var isArray = __webpack_require__(5);
|
||
|
||
var clone = function clone(obj) {
|
||
if ((typeof obj === 'undefined' ? 'undefined' : _typeof(obj)) !== 'object' || obj === null) {
|
||
return obj;
|
||
}
|
||
|
||
var rst = void 0;
|
||
|
||
if (isArray(obj)) {
|
||
rst = [];
|
||
|
||
for (var i = 0, l = obj.length; i < l; i++) {
|
||
if (_typeof(obj[i]) === 'object' && obj[i] != null) {
|
||
rst[i] = clone(obj[i]);
|
||
} else {
|
||
rst[i] = obj[i];
|
||
}
|
||
}
|
||
} else {
|
||
rst = {};
|
||
|
||
for (var k in obj) {
|
||
if (_typeof(obj[k]) === 'object' && obj[k] != null) {
|
||
rst[k] = clone(obj[k]);
|
||
} else {
|
||
rst[k] = obj[k];
|
||
}
|
||
}
|
||
}
|
||
|
||
return rst;
|
||
};
|
||
|
||
module.exports = clone;
|
||
|
||
/***/ }),
|
||
/* 16 */
|
||
/***/ (function(module, exports) {
|
||
|
||
var toString = {}.toString;
|
||
|
||
var isType = function isType(value, type) {
|
||
return toString.call(value) === '[object ' + type + ']';
|
||
};
|
||
|
||
module.exports = isType;
|
||
|
||
/***/ }),
|
||
/* 17 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
var isObject = __webpack_require__(18);
|
||
|
||
var isArray = __webpack_require__(5);
|
||
|
||
var each = function each(elements, func) {
|
||
if (!elements) {
|
||
return;
|
||
}
|
||
|
||
var rst = void 0;
|
||
|
||
if (isArray(elements)) {
|
||
for (var i = 0, len = elements.length; i < len; i++) {
|
||
rst = func(elements[i], i);
|
||
|
||
if (rst === false) {
|
||
break;
|
||
}
|
||
}
|
||
} else if (isObject(elements)) {
|
||
for (var k in elements) {
|
||
if (elements.hasOwnProperty(k)) {
|
||
rst = func(elements[k], k);
|
||
|
||
if (rst === false) {
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
};
|
||
|
||
module.exports = each;
|
||
|
||
/***/ }),
|
||
/* 18 */
|
||
/***/ (function(module, exports) {
|
||
|
||
var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) {
|
||
return typeof obj;
|
||
} : function (obj) {
|
||
return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
|
||
};
|
||
|
||
var isObject = function isObject(value) {
|
||
/**
|
||
* isObject({}) => true
|
||
* isObject([1, 2, 3]) => true
|
||
* isObject(Function) => true
|
||
* isObject(null) => false
|
||
*/
|
||
var type = typeof value === 'undefined' ? 'undefined' : _typeof(value);
|
||
return value !== null && type === 'object' || type === 'function';
|
||
};
|
||
|
||
module.exports = isObject;
|
||
|
||
/***/ }),
|
||
/* 19 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
|
||
|
||
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
||
|
||
function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
|
||
|
||
function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
|
||
|
||
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); } }
|
||
|
||
function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
|
||
|
||
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
|
||
|
||
function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
|
||
|
||
function _get(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get; } else { _get = function _get(target, property, receiver) { var base = _superPropBase(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get(target, property, receiver || target); }
|
||
|
||
function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; }
|
||
|
||
function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
|
||
|
||
/**
|
||
* @fileOverview the class of Cartesian Coordinate
|
||
* @author sima.zhang
|
||
*/
|
||
var mix = __webpack_require__(1);
|
||
|
||
var Base = __webpack_require__(0);
|
||
|
||
var Cartesian =
|
||
/*#__PURE__*/
|
||
function (_Base) {
|
||
_inherits(Cartesian, _Base);
|
||
|
||
_createClass(Cartesian, [{
|
||
key: "getDefaultCfg",
|
||
|
||
/**
|
||
* @override
|
||
*/
|
||
value: function getDefaultCfg() {
|
||
var cfg = _get(_getPrototypeOf(Cartesian.prototype), "getDefaultCfg", this).call(this);
|
||
|
||
return mix({}, cfg, {
|
||
start: {
|
||
x: 0,
|
||
y: 0
|
||
},
|
||
end: {
|
||
x: 0,
|
||
y: 0
|
||
},
|
||
type: 'cartesian',
|
||
isRect: true
|
||
});
|
||
}
|
||
}]);
|
||
|
||
function Cartesian(cfg) {
|
||
var _this;
|
||
|
||
_classCallCheck(this, Cartesian);
|
||
|
||
_this = _possibleConstructorReturn(this, _getPrototypeOf(Cartesian).call(this, cfg));
|
||
|
||
_this._init();
|
||
|
||
return _this;
|
||
}
|
||
|
||
_createClass(Cartesian, [{
|
||
key: "_init",
|
||
value: function _init() {
|
||
var start = this.start,
|
||
end = this.end;
|
||
var x = {
|
||
start: start.x,
|
||
end: end.x
|
||
};
|
||
var y = {
|
||
start: start.y,
|
||
end: end.y
|
||
};
|
||
this.x = x;
|
||
this.y = y;
|
||
}
|
||
}, {
|
||
key: "convertPoint",
|
||
value: function convertPoint(point) {
|
||
var x;
|
||
var y;
|
||
|
||
if (this.isTransposed) {
|
||
x = point.y;
|
||
y = point.x;
|
||
} else {
|
||
x = point.x;
|
||
y = point.y;
|
||
}
|
||
|
||
return {
|
||
x: this.convertDim(x, 'x'),
|
||
y: this.convertDim(y, 'y')
|
||
};
|
||
}
|
||
}, {
|
||
key: "invertPoint",
|
||
value: function invertPoint(point) {
|
||
var x = this.invertDim(point.x, 'x');
|
||
var y = this.invertDim(point.y, 'y');
|
||
|
||
if (this.isTransposed) {
|
||
return {
|
||
x: y,
|
||
y: x
|
||
};
|
||
}
|
||
|
||
return {
|
||
x: x,
|
||
y: y
|
||
};
|
||
}
|
||
}]);
|
||
|
||
return Cartesian;
|
||
}(Base);
|
||
|
||
module.exports = Cartesian;
|
||
|
||
/***/ }),
|
||
/* 20 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
|
||
|
||
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
||
|
||
function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
|
||
|
||
function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
|
||
|
||
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); } }
|
||
|
||
function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
|
||
|
||
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
|
||
|
||
function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
|
||
|
||
function _get(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get; } else { _get = function _get(target, property, receiver) { var base = _superPropBase(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get(target, property, receiver || target); }
|
||
|
||
function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; }
|
||
|
||
function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
|
||
|
||
/**
|
||
* @fileOverview the class of Polar Coordinate
|
||
* @author sima.zhang
|
||
*/
|
||
var MatrixUtil = __webpack_require__(2);
|
||
|
||
var isNumberEqual = __webpack_require__(6);
|
||
|
||
var mix = __webpack_require__(1);
|
||
|
||
var Base = __webpack_require__(0);
|
||
|
||
var mat3 = MatrixUtil.mat3;
|
||
var vec2 = MatrixUtil.vec2;
|
||
var vec3 = MatrixUtil.vec3;
|
||
|
||
var Polar =
|
||
/*#__PURE__*/
|
||
function (_Base) {
|
||
_inherits(Polar, _Base);
|
||
|
||
_createClass(Polar, [{
|
||
key: "getDefaultCfg",
|
||
value: function getDefaultCfg() {
|
||
var cfg = _get(_getPrototypeOf(Polar.prototype), "getDefaultCfg", this).call(this);
|
||
|
||
return mix({}, cfg, {
|
||
startAngle: -Math.PI / 2,
|
||
endAngle: Math.PI * 3 / 2,
|
||
innerRadius: 0,
|
||
type: 'polar',
|
||
isPolar: true
|
||
});
|
||
}
|
||
}]);
|
||
|
||
function Polar(cfg) {
|
||
var _this;
|
||
|
||
_classCallCheck(this, Polar);
|
||
|
||
_this = _possibleConstructorReturn(this, _getPrototypeOf(Polar).call(this, cfg));
|
||
|
||
_this._init();
|
||
|
||
return _this;
|
||
}
|
||
|
||
_createClass(Polar, [{
|
||
key: "_init",
|
||
value: function _init() {
|
||
var radius = this.radius;
|
||
var innerRadius = this.innerRadius;
|
||
var center = this.center;
|
||
var startAngle = this.startAngle;
|
||
var endAngle = this.endAngle;
|
||
|
||
while (endAngle < startAngle) {
|
||
endAngle += Math.PI * 2;
|
||
}
|
||
|
||
this.endAngle = endAngle;
|
||
var oneBox = this.getOneBox();
|
||
var oneWidth = oneBox.maxX - oneBox.minX;
|
||
var oneHeight = oneBox.maxY - oneBox.minY;
|
||
var left = Math.abs(oneBox.minX) / oneWidth;
|
||
var top = Math.abs(oneBox.minY) / oneHeight;
|
||
var width = this.width;
|
||
var height = this.height;
|
||
var maxRadius;
|
||
var circleCentre;
|
||
|
||
if (height / oneHeight > width / oneWidth) {
|
||
// width为主
|
||
maxRadius = width / oneWidth;
|
||
circleCentre = {
|
||
x: center.x - (0.5 - left) * width,
|
||
y: center.y - (0.5 - top) * maxRadius * oneHeight
|
||
};
|
||
} else {
|
||
// height为主
|
||
maxRadius = height / oneHeight;
|
||
circleCentre = {
|
||
x: center.x - (0.5 - left) * maxRadius * oneWidth,
|
||
y: center.y - (0.5 - top) * height
|
||
};
|
||
}
|
||
|
||
if (!radius) {
|
||
radius = maxRadius;
|
||
} else if (radius > 0 && radius <= 1) {
|
||
radius = maxRadius * radius;
|
||
} else if (radius <= 0 || radius > maxRadius) {
|
||
radius = maxRadius;
|
||
}
|
||
|
||
var x = {
|
||
start: startAngle,
|
||
end: endAngle
|
||
};
|
||
var y = {
|
||
start: innerRadius * radius,
|
||
end: radius
|
||
};
|
||
this.x = x;
|
||
this.y = y;
|
||
this.radius = radius;
|
||
this.circleCentre = circleCentre;
|
||
this.center = circleCentre;
|
||
}
|
||
}, {
|
||
key: "getCenter",
|
||
value: function getCenter() {
|
||
return this.circleCentre;
|
||
}
|
||
}, {
|
||
key: "getOneBox",
|
||
value: function getOneBox() {
|
||
var startAngle = this.startAngle;
|
||
var endAngle = this.endAngle;
|
||
|
||
if (Math.abs(endAngle - startAngle) >= Math.PI * 2) {
|
||
return {
|
||
minX: -1,
|
||
maxX: 1,
|
||
minY: -1,
|
||
maxY: 1
|
||
};
|
||
}
|
||
|
||
var xs = [0, Math.cos(startAngle), Math.cos(endAngle)];
|
||
var ys = [0, Math.sin(startAngle), Math.sin(endAngle)];
|
||
|
||
for (var i = Math.min(startAngle, endAngle); i < Math.max(startAngle, endAngle); i += Math.PI / 18) {
|
||
xs.push(Math.cos(i));
|
||
ys.push(Math.sin(i));
|
||
}
|
||
|
||
return {
|
||
minX: Math.min.apply(Math, xs),
|
||
maxX: Math.max.apply(Math, xs),
|
||
minY: Math.min.apply(Math, ys),
|
||
maxY: Math.max.apply(Math, ys)
|
||
};
|
||
}
|
||
}, {
|
||
key: "getRadius",
|
||
value: function getRadius() {
|
||
return this.radius;
|
||
}
|
||
}, {
|
||
key: "convertPoint",
|
||
value: function convertPoint(point) {
|
||
var center = this.getCenter();
|
||
var x = this.isTransposed ? point.y : point.x;
|
||
var y = this.isTransposed ? point.x : point.y;
|
||
x = this.convertDim(x, 'x');
|
||
y = this.convertDim(y, 'y');
|
||
return {
|
||
x: center.x + Math.cos(x) * y,
|
||
y: center.y + Math.sin(x) * y
|
||
};
|
||
}
|
||
}, {
|
||
key: "invertPoint",
|
||
value: function invertPoint(point) {
|
||
var center = this.getCenter();
|
||
var vPoint = [point.x - center.x, point.y - center.y];
|
||
var x = this.x;
|
||
var m = [1, 0, 0, 0, 1, 0, 0, 0, 1];
|
||
mat3.rotate(m, m, x.start);
|
||
var vStart = [1, 0, 0];
|
||
vec3.transformMat3(vStart, vStart, m);
|
||
vStart = [vStart[0], vStart[1]];
|
||
var angle = vec2.angleTo(vStart, vPoint, x.end < x.start);
|
||
|
||
if (isNumberEqual(angle, Math.PI * 2)) {
|
||
angle = 0;
|
||
}
|
||
|
||
var radius = vec2.length(vPoint);
|
||
var xPercent = angle / (x.end - x.start);
|
||
xPercent = x.end - x.start > 0 ? xPercent : -xPercent;
|
||
var yPercent = this.invertDim(radius, 'y');
|
||
var rst = {};
|
||
rst.x = this.isTransposed ? yPercent : xPercent;
|
||
rst.y = this.isTransposed ? xPercent : yPercent;
|
||
return rst;
|
||
}
|
||
}]);
|
||
|
||
return Polar;
|
||
}(Base);
|
||
|
||
module.exports = Polar;
|
||
|
||
/***/ }),
|
||
/* 21 */
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
|
||
|
||
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
||
|
||
function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
|
||
|
||
function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
|
||
|
||
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); } }
|
||
|
||
function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
|
||
|
||
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
|
||
|
||
function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
|
||
|
||
function _get(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get; } else { _get = function _get(target, property, receiver) { var base = _superPropBase(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get(target, property, receiver || target); }
|
||
|
||
function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; }
|
||
|
||
function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
|
||
|
||
/**
|
||
* @fileOverview the class of Helix Coordinate
|
||
* @author sima.zhang
|
||
*/
|
||
var MatrixUtil = __webpack_require__(2);
|
||
|
||
var isNumberEqual = __webpack_require__(6);
|
||
|
||
var mix = __webpack_require__(1);
|
||
|
||
var Base = __webpack_require__(0);
|
||
|
||
var vec2 = MatrixUtil.vec2;
|
||
|
||
var Helix =
|
||
/*#__PURE__*/
|
||
function (_Base) {
|
||
_inherits(Helix, _Base);
|
||
|
||
_createClass(Helix, [{
|
||
key: "getDefaultCfg",
|
||
value: function getDefaultCfg() {
|
||
var cfg = _get(_getPrototypeOf(Helix.prototype), "getDefaultCfg", this).call(this);
|
||
|
||
return mix({}, cfg, {
|
||
startAngle: 1.25 * Math.PI,
|
||
endAngle: 7.25 * Math.PI,
|
||
innerRadius: 0,
|
||
type: 'helix',
|
||
isHelix: true
|
||
});
|
||
}
|
||
}]);
|
||
|
||
function Helix(cfg) {
|
||
var _this;
|
||
|
||
_classCallCheck(this, Helix);
|
||
|
||
_this = _possibleConstructorReturn(this, _getPrototypeOf(Helix).call(this, cfg));
|
||
|
||
_this._init();
|
||
|
||
return _this;
|
||
}
|
||
|
||
_createClass(Helix, [{
|
||
key: "_init",
|
||
value: function _init() {
|
||
var width = this.width;
|
||
var height = this.height;
|
||
var radius = this.radius;
|
||
var innerRadius = this.innerRadius;
|
||
var startAngle = this.startAngle;
|
||
var endAngle = this.endAngle;
|
||
var index = (endAngle - startAngle) / (2 * Math.PI) + 1; // 螺线圈数
|
||
|
||
var maxRadius = Math.min(width, height) / 2;
|
||
|
||
if (radius && radius >= 0 && radius <= 1) {
|
||
maxRadius = maxRadius * radius;
|
||
}
|
||
|
||
var d = Math.floor(maxRadius * (1 - innerRadius) / index);
|
||
var a = d / (Math.PI * 2); // 螺线系数
|
||
|
||
var x = {
|
||
start: startAngle,
|
||
end: endAngle
|
||
};
|
||
var y = {
|
||
start: innerRadius * maxRadius,
|
||
end: innerRadius * maxRadius + d * 0.99
|
||
};
|
||
this.a = a;
|
||
this.d = d;
|
||
this.x = x;
|
||
this.y = y;
|
||
}
|
||
}, {
|
||
key: "getCenter",
|
||
value: function getCenter() {
|
||
return this.center;
|
||
}
|
||
/**
|
||
* 将百分比数据变成屏幕坐标
|
||
* @param {Object} point 归一化的点坐标
|
||
* @return {Object} 返回对应的屏幕坐标
|
||
*/
|
||
|
||
}, {
|
||
key: "convertPoint",
|
||
value: function convertPoint(point) {
|
||
var a = this.a;
|
||
var center = this.center;
|
||
var x;
|
||
var y;
|
||
|
||
if (this.isTransposed) {
|
||
x = point.y;
|
||
y = point.x;
|
||
} else {
|
||
x = point.x;
|
||
y = point.y;
|
||
}
|
||
|
||
var thi = this.convertDim(x, 'x');
|
||
var r = a * thi;
|
||
var newY = this.convertDim(y, 'y');
|
||
return {
|
||
x: center.x + Math.cos(thi) * (r + newY),
|
||
y: center.y + Math.sin(thi) * (r + newY)
|
||
};
|
||
}
|
||
/**
|
||
* 将屏幕坐标点还原成百分比数据
|
||
* @param {Object} point 屏幕坐标
|
||
* @return {Object} 返回对应的归一化后的数据
|
||
*/
|
||
|
||
}, {
|
||
key: "invertPoint",
|
||
value: function invertPoint(point) {
|
||
var center = this.center;
|
||
var a = this.a;
|
||
var d = this.d + this.y.start;
|
||
var v = vec2.subtract([], [point.x, point.y], [center.x, center.y]);
|
||
var thi = vec2.angleTo(v, [1, 0], true);
|
||
var rMin = thi * a; // 坐标与原点的连线在第一圈上的交点，最小r值
|
||
|
||
if (vec2.length(v) < rMin) {
|
||
// 坐标与原点的连线不可能小于最小r值，但不排除因小数计算产生的略小于rMin的情况
|
||
rMin = vec2.length(v);
|
||
}
|
||
|
||
var index = Math.floor((vec2.length(v) - rMin) / d); // 当前点位于第index圈
|
||
|
||
thi = 2 * index * Math.PI + thi;
|
||
var r = a * thi;
|
||
var newY = vec2.length(v) - r;
|
||
newY = isNumberEqual(newY, 0) ? 0 : newY;
|
||
var x = this.invertDim(thi, 'x');
|
||
var y = this.invertDim(newY, 'y');
|
||
x = isNumberEqual(x, 0) ? 0 : x;
|
||
y = isNumberEqual(y, 0) ? 0 : y;
|
||
var rst = {};
|
||
rst.x = this.isTransposed ? y : x;
|
||
rst.y = this.isTransposed ? x : y;
|
||
return rst;
|
||
}
|
||
}]);
|
||
|
||
return Helix;
|
||
}(Base);
|
||
|
||
module.exports = Helix;
|
||
|
||
/***/ })
|
||
/******/ ]);
|
||
});
|
||
//# sourceMappingURL=coord.js.map |