Source: vec2.js

  1. import * as glMatrix from "./common.js";
  3. /**
  4.  * 2 Dimensional Vector
  5.  * @module vec2
  6.  */
  8. /**
  9.  * Creates a new, empty vec2
  10.  *
  11.  * @returns {vec2} a new 2D vector
  12.  */
  13. export function create() {
  14.   let out = new glMatrix.ARRAY_TYPE(2);
  15.   if(glMatrix.ARRAY_TYPE != Float32Array) {
  16.     out[0] = 0;
  17.     out[1] = 0;
  18.   }
  19.   return out;
  20. }
  22. /**
  23.  * Creates a new vec2 initialized with values from an existing vector
  24.  *
  25.  * @param {vec2} a vector to clone
  26.  * @returns {vec2} a new 2D vector
  27.  */
  28. export function clone(a) {
  29.   let out = new glMatrix.ARRAY_TYPE(2);
  30.   out[0] = a[0];
  31.   out[1] = a[1];
  32.   return out;
  33. }
  35. /**
  36.  * Creates a new vec2 initialized with the given values
  37.  *
  38.  * @param {Number} x X component
  39.  * @param {Number} y Y component
  40.  * @returns {vec2} a new 2D vector
  41.  */
  42. export function fromValues(x, y) {
  43.   let out = new glMatrix.ARRAY_TYPE(2);
  44.   out[0] = x;
  45.   out[1] = y;
  46.   return out;
  47. }
  49. /**
  50.  * Copy the values from one vec2 to another
  51.  *
  52.  * @param {vec2} out the receiving vector
  53.  * @param {vec2} a the source vector
  54.  * @returns {vec2} out
  55.  */
  56. export function copy(out, a) {
  57.   out[0] = a[0];
  58.   out[1] = a[1];
  59.   return out;
  60. }
  62. /**
  63.  * Set the components of a vec2 to the given values
  64.  *
  65.  * @param {vec2} out the receiving vector
  66.  * @param {Number} x X component
  67.  * @param {Number} y Y component
  68.  * @returns {vec2} out
  69.  */
  70. export function set(out, x, y) {
  71.   out[0] = x;
  72.   out[1] = y;
  73.   return out;
  74. }
  76. /**
  77.  * Adds two vec2's
  78.  *
  79.  * @param {vec2} out the receiving vector
  80.  * @param {vec2} a the first operand
  81.  * @param {vec2} b the second operand
  82.  * @returns {vec2} out
  83.  */
  84. export function add(out, a, b) {
  85.   out[0] = a[0] + b[0];
  86.   out[1] = a[1] + b[1];
  87.   return out;
  88. }
  90. /**
  91.  * Subtracts vector b from vector a
  92.  *
  93.  * @param {vec2} out the receiving vector
  94.  * @param {vec2} a the first operand
  95.  * @param {vec2} b the second operand
  96.  * @returns {vec2} out
  97.  */
  98. export function subtract(out, a, b) {
  99.   out[0] = a[0] - b[0];
  100.   out[1] = a[1] - b[1];
  101.   return out;
  102. }
  104. /**
  105.  * Multiplies two vec2's
  106.  *
  107.  * @param {vec2} out the receiving vector
  108.  * @param {vec2} a the first operand
  109.  * @param {vec2} b the second operand
  110.  * @returns {vec2} out
  111.  */
  112. export function multiply(out, a, b) {
  113.   out[0] = a[0] * b[0];
  114.   out[1] = a[1] * b[1];
  115.   return out;
  116. }
  118. /**
  119.  * Divides two vec2's
  120.  *
  121.  * @param {vec2} out the receiving vector
  122.  * @param {vec2} a the first operand
  123.  * @param {vec2} b the second operand
  124.  * @returns {vec2} out
  125.  */
  126. export function divide(out, a, b) {
  127.   out[0] = a[0] / b[0];
  128.   out[1] = a[1] / b[1];
  129.   return out;
  130. }
  132. /**
  133.  * Math.ceil the components of a vec2
  134.  *
  135.  * @param {vec2} out the receiving vector
  136.  * @param {vec2} a vector to ceil
  137.  * @returns {vec2} out
  138.  */
  139. export function ceil(out, a) {
  140.   out[0] = Math.ceil(a[0]);
  141.   out[1] = Math.ceil(a[1]);
  142.   return out;
  143. }
  145. /**
  146.  * Math.floor the components of a vec2
  147.  *
  148.  * @param {vec2} out the receiving vector
  149.  * @param {vec2} a vector to floor
  150.  * @returns {vec2} out
  151.  */
  152. export function floor(out, a) {
  153.   out[0] = Math.floor(a[0]);
  154.   out[1] = Math.floor(a[1]);
  155.   return out;
  156. }
  158. /**
  159.  * Returns the minimum of two vec2's
  160.  *
  161.  * @param {vec2} out the receiving vector
  162.  * @param {vec2} a the first operand
  163.  * @param {vec2} b the second operand
  164.  * @returns {vec2} out
  165.  */
  166. export function min(out, a, b) {
  167.   out[0] = Math.min(a[0], b[0]);
  168.   out[1] = Math.min(a[1], b[1]);
  169.   return out;
  170. }
  172. /**
  173.  * Returns the maximum of two vec2's
  174.  *
  175.  * @param {vec2} out the receiving vector
  176.  * @param {vec2} a the first operand
  177.  * @param {vec2} b the second operand
  178.  * @returns {vec2} out
  179.  */
  180. export function max(out, a, b) {
  181.   out[0] = Math.max(a[0], b[0]);
  182.   out[1] = Math.max(a[1], b[1]);
  183.   return out;
  184. }
  186. /**
  187.  * Math.round the components of a vec2
  188.  *
  189.  * @param {vec2} out the receiving vector
  190.  * @param {vec2} a vector to round
  191.  * @returns {vec2} out
  192.  */
  193. export function round (out, a) {
  194.   out[0] = Math.round(a[0]);
  195.   out[1] = Math.round(a[1]);
  196.   return out;
  197. }
  199. /**
  200.  * Scales a vec2 by a scalar number
  201.  *
  202.  * @param {vec2} out the receiving vector
  203.  * @param {vec2} a the vector to scale
  204.  * @param {Number} b amount to scale the vector by
  205.  * @returns {vec2} out
  206.  */
  207. export function scale(out, a, b) {
  208.   out[0] = a[0] * b;
  209.   out[1] = a[1] * b;
  210.   return out;
  211. }
  213. /**
  214.  * Adds two vec2's after scaling the second operand by a scalar value
  215.  *
  216.  * @param {vec2} out the receiving vector
  217.  * @param {vec2} a the first operand
  218.  * @param {vec2} b the second operand
  219.  * @param {Number} scale the amount to scale b by before adding
  220.  * @returns {vec2} out
  221.  */
  222. export function scaleAndAdd(out, a, b, scale) {
  223.   out[0] = a[0] + (b[0] * scale);
  224.   out[1] = a[1] + (b[1] * scale);
  225.   return out;
  226. }
  228. /**
  229.  * Calculates the euclidian distance between two vec2's
  230.  *
  231.  * @param {vec2} a the first operand
  232.  * @param {vec2} b the second operand
  233.  * @returns {Number} distance between a and b
  234.  */
  235. export function distance(a, b) {
  236.   var x = b[0] - a[0],
  237.     y = b[1] - a[1];
  238.   return Math.sqrt(x*x + y*y);
  239. }
  241. /**
  242.  * Calculates the squared euclidian distance between two vec2's
  243.  *
  244.  * @param {vec2} a the first operand
  245.  * @param {vec2} b the second operand
  246.  * @returns {Number} squared distance between a and b
  247.  */
  248. export function squaredDistance(a, b) {
  249.   var x = b[0] - a[0],
  250.     y = b[1] - a[1];
  251.   return x*x + y*y;
  252. }
  254. /**
  255.  * Calculates the length of a vec2
  256.  *
  257.  * @param {vec2} a vector to calculate length of
  258.  * @returns {Number} length of a
  259.  */
  260. export function length(a) {
  261.   var x = a[0],
  262.     y = a[1];
  263.   return Math.sqrt(x*x + y*y);
  264. }
  266. /**
  267.  * Calculates the squared length of a vec2
  268.  *
  269.  * @param {vec2} a vector to calculate squared length of
  270.  * @returns {Number} squared length of a
  271.  */
  272. export function squaredLength (a) {
  273.   var x = a[0],
  274.     y = a[1];
  275.   return x*x + y*y;
  276. }
  278. /**
  279.  * Negates the components of a vec2
  280.  *
  281.  * @param {vec2} out the receiving vector
  282.  * @param {vec2} a vector to negate
  283.  * @returns {vec2} out
  284.  */
  285. export function negate(out, a) {
  286.   out[0] = -a[0];
  287.   out[1] = -a[1];
  288.   return out;
  289. }
  291. /**
  292.  * Returns the inverse of the components of a vec2
  293.  *
  294.  * @param {vec2} out the receiving vector
  295.  * @param {vec2} a vector to invert
  296.  * @returns {vec2} out
  297.  */
  298. export function inverse(out, a) {
  299.   out[0] = 1.0 / a[0];
  300.   out[1] = 1.0 / a[1];
  301.   return out;
  302. }
  304. /**
  305.  * Normalize a vec2
  306.  *
  307.  * @param {vec2} out the receiving vector
  308.  * @param {vec2} a vector to normalize
  309.  * @returns {vec2} out
  310.  */
  311. export function normalize(out, a) {
  312.   var x = a[0],
  313.     y = a[1];
  314.   var len = x*x + y*y;
  315.   if (len > 0) {
  316.     //TODO: evaluate use of glm_invsqrt here?
  317.     len = 1 / Math.sqrt(len);
  318.     out[0] = a[0] * len;
  319.     out[1] = a[1] * len;
  320.   }
  321.   return out;
  322. }
  324. /**
  325.  * Calculates the dot product of two vec2's
  326.  *
  327.  * @param {vec2} a the first operand
  328.  * @param {vec2} b the second operand
  329.  * @returns {Number} dot product of a and b
  330.  */
  331. export function dot(a, b) {
  332.   return a[0] * b[0] + a[1] * b[1];
  333. }
  335. /**
  336.  * Computes the cross product of two vec2's
  337.  * Note that the cross product must by definition produce a 3D vector
  338.  *
  339.  * @param {vec3} out the receiving vector
  340.  * @param {vec2} a the first operand
  341.  * @param {vec2} b the second operand
  342.  * @returns {vec3} out
  343.  */
  344. export function cross(out, a, b) {
  345.   var z = a[0] * b[1] - a[1] * b[0];
  346.   out[0] = out[1] = 0;
  347.   out[2] = z;
  348.   return out;
  349. }
  351. /**
  352.  * Performs a linear interpolation between two vec2's
  353.  *
  354.  * @param {vec2} out the receiving vector
  355.  * @param {vec2} a the first operand
  356.  * @param {vec2} b the second operand
  357.  * @param {Number} t interpolation amount, in the range [0-1], between the two inputs
  358.  * @returns {vec2} out
  359.  */
  360. export function lerp(out, a, b, t) {
  361.   var ax = a[0],
  362.     ay = a[1];
  363.   out[0] = ax + t * (b[0] - ax);
  364.   out[1] = ay + t * (b[1] - ay);
  365.   return out;
  366. }
  368. /**
  369.  * Generates a random vector with the given scale
  370.  *
  371.  * @param {vec2} out the receiving vector
  372.  * @param {Number} [scale] Length of the resulting vector. If ommitted, a unit vector will be returned
  373.  * @returns {vec2} out
  374.  */
  375. export function random(out, scale) {
  376.   scale = scale || 1.0;
  377.   var r = glMatrix.RANDOM() * 2.0 * Math.PI;
  378.   out[0] = Math.cos(r) * scale;
  379.   out[1] = Math.sin(r) * scale;
  380.   return out;
  381. }
  383. /**
  384.  * Transforms the vec2 with a mat2
  385.  *
  386.  * @param {vec2} out the receiving vector
  387.  * @param {vec2} a the vector to transform
  388.  * @param {mat2} m matrix to transform with
  389.  * @returns {vec2} out
  390.  */
  391. export function transformMat2(out, a, m) {
  392.   var x = a[0],
  393.     y = a[1];
  394.   out[0] = m[0] * x + m[2] * y;
  395.   out[1] = m[1] * x + m[3] * y;
  396.   return out;
  397. }
  399. /**
  400.  * Transforms the vec2 with a mat2d
  401.  *
  402.  * @param {vec2} out the receiving vector
  403.  * @param {vec2} a the vector to transform
  404.  * @param {mat2d} m matrix to transform with
  405.  * @returns {vec2} out
  406.  */
  407. export function transformMat2d(out, a, m) {
  408.   var x = a[0],
  409.     y = a[1];
  410.   out[0] = m[0] * x + m[2] * y + m[4];
  411.   out[1] = m[1] * x + m[3] * y + m[5];
  412.   return out;
  413. }
  415. /**
  416.  * Transforms the vec2 with a mat3
  417.  * 3rd vector component is implicitly '1'
  418.  *
  419.  * @param {vec2} out the receiving vector
  420.  * @param {vec2} a the vector to transform
  421.  * @param {mat3} m matrix to transform with
  422.  * @returns {vec2} out
  423.  */
  424. export function transformMat3(out, a, m) {
  425.   var x = a[0],
  426.     y = a[1];
  427.   out[0] = m[0] * x + m[3] * y + m[6];
  428.   out[1] = m[1] * x + m[4] * y + m[7];
  429.   return out;
  430. }
  432. /**
  433.  * Transforms the vec2 with a mat4
  434.  * 3rd vector component is implicitly '0'
  435.  * 4th vector component is implicitly '1'
  436.  *
  437.  * @param {vec2} out the receiving vector
  438.  * @param {vec2} a the vector to transform
  439.  * @param {mat4} m matrix to transform with
  440.  * @returns {vec2} out
  441.  */
  442. export function transformMat4(out, a, m) {
  443.   let x = a[0];
  444.   let y = a[1];
  445.   out[0] = m[0] * x + m[4] * y + m[12];
  446.   out[1] = m[1] * x + m[5] * y + m[13];
  447.   return out;
  448. }
  450. /**
  451.  * Rotate a 2D vector
  452.  * @param {vec2} out The receiving vec2
  453.  * @param {vec2} a The vec2 point to rotate
  454.  * @param {vec2} b The origin of the rotation
  455.  * @param {Number} c The angle of rotation
  456.  * @returns {vec2} out
  457.  */
  458. export function rotate(out, a, b, c) {
  459.   //Translate point to the origin
  460.   let p0 = a[0] - b[0],
  461.   p1 = a[1] - b[1],
  462.   sinC = Math.sin(c),
  463.   cosC = Math.cos(c);
  464.   
  465.   //perform rotation and translate to correct position
  466.   out[0] = p0*cosC - p1*sinC + b[0];
  467.   out[1] = p0*sinC + p1*cosC + b[1];
  469.   return out;
  470. }
  472. /**
  473.  * Get the angle between two 2D vectors
  474.  * @param {vec2} a The first operand
  475.  * @param {vec2} b The second operand
  476.  * @returns {Number} The angle in radians
  477.  */
  478. export function angle(a, b) {
  479.   let x1 = a[0],
  480.     y1 = a[1],
  481.     x2 = b[0],
  482.     y2 = b[1];
  483.   
  484.   let len1 = x1*x1 + y1*y1;
  485.   if (len1 > 0) {
  486.     //TODO: evaluate use of glm_invsqrt here?
  487.     len1 = 1 / Math.sqrt(len1);
  488.   }
  489.   
  490.   let len2 = x2*x2 + y2*y2;
  491.   if (len2 > 0) {
  492.     //TODO: evaluate use of glm_invsqrt here?
  493.     len2 = 1 / Math.sqrt(len2);
  494.   }
  495.   
  496.   let cosine = (x1 * x2 + y1 * y2) * len1 * len2;
  497.   
  498.   
  499.   if(cosine > 1.0) {
  500.     return 0;
  501.   }
  502.   else if(cosine < -1.0) {
  503.     return Math.PI;
  504.   } else {
  505.     return Math.acos(cosine);
  506.   }
  507. }
  509. /**
  510.  * Returns a string representation of a vector
  511.  *
  512.  * @param {vec2} a vector to represent as a string
  513.  * @returns {String} string representation of the vector
  514.  */
  515. export function str(a) {
  516.   return 'vec2(' + a[0] + ', ' + a[1] + ')';
  517. }
  519. /**
  520.  * Returns whether or not the vectors exactly have the same elements in the same position (when compared with ===)
  521.  *
  522.  * @param {vec2} a The first vector.
  523.  * @param {vec2} b The second vector.
  524.  * @returns {Boolean} True if the vectors are equal, false otherwise.
  525.  */
  526. export function exactEquals(a, b) {
  527.   return a[0] === b[0] && a[1] === b[1];
  528. }
  530. /**
  531.  * Returns whether or not the vectors have approximately the same elements in the same position.
  532.  *
  533.  * @param {vec2} a The first vector.
  534.  * @param {vec2} b The second vector.
  535.  * @returns {Boolean} True if the vectors are equal, false otherwise.
  536.  */
  537. export function equals(a, b) {
  538.   let a0 = a[0], a1 = a[1];
  539.   let b0 = b[0], b1 = b[1];
  540.   return (Math.abs(a0 - b0) <= glMatrix.EPSILON*Math.max(1.0, Math.abs(a0), Math.abs(b0)) &&
  541.           Math.abs(a1 - b1) <= glMatrix.EPSILON*Math.max(1.0, Math.abs(a1), Math.abs(b1)));
  542. }
  544. /**
  545.  * Alias for {@link vec2.length}
  546.  * @function
  547.  */
  548. export const len = length;
  550. /**
  551.  * Alias for {@link vec2.subtract}
  552.  * @function
  553.  */
  554. export const sub = subtract;
  556. /**
  557.  * Alias for {@link vec2.multiply}
  558.  * @function
  559.  */
  560. export const mul = multiply;
  562. /**
  563.  * Alias for {@link vec2.divide}
  564.  * @function
  565.  */
  566. export const div = divide;
  568. /**
  569.  * Alias for {@link vec2.distance}
  570.  * @function
  571.  */
  572. export const dist = distance;
  574. /**
  575.  * Alias for {@link vec2.squaredDistance}
  576.  * @function
  577.  */
  578. export const sqrDist = squaredDistance;
  580. /**
  581.  * Alias for {@link vec2.squaredLength}
  582.  * @function
  583.  */
  584. export const sqrLen = squaredLength;
  586. /**
  587.  * Perform some operation over an array of vec2s.
  588.  *
  589.  * @param {Array} a the array of vectors to iterate over
  590.  * @param {Number} stride Number of elements between the start of each vec2. If 0 assumes tightly packed
  591.  * @param {Number} offset Number of elements to skip at the beginning of the array
  592.  * @param {Number} count Number of vec2s to iterate over. If 0 iterates over entire array
  593.  * @param {Function} fn Function to call for each vector in the array
  594.  * @param {Object} [arg] additional argument to pass to fn
  595.  * @returns {Array} a
  596.  * @function
  597.  */
  598. export const forEach = (function() {
  599.   let vec = create();
  601.   return function(a, stride, offset, count, fn, arg) {
  602.     let i, l;
  603.     if(!stride) {
  604.       stride = 2;
  605.     }
  607.     if(!offset) {
  608.       offset = 0;
  609.     }
  611.     if(count) {
  612.       l = Math.min((count * stride) + offset, a.length);
  613.     } else {
  614.       l = a.length;
  615.     }
  617.     for(i = offset; i < l; i += stride) {
  618.       vec[0] = a[i]; vec[1] = a[i+1];
  619.       fn(vec, vec, arg);
  620.       a[i] = vec[0]; a[i+1] = vec[1];
  621.     }
  623.     return a;
  624.   };
  625. })();