Added type defs for gl-vec2

types/gl-vec2/add.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Adds two vec2's
+ */
+declare function add(out: number[], a: number[], b: number[]): number[];
+
+export = add;

types/gl-vec2/clone.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Creates a new vec2 initialized with values from an existing vector
+ */
+declare function clone(a: number[]): number[];
+
+export = clone;

types/gl-vec2/copy.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Copy the values from one vec2 to another.
+ */
+declare function copy(out: number[], a: number[]): number[];
+
+export = copy;

types/gl-vec2/create.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Creates a new, empty vec2.
+ */
+declare function create(): number[];
+
+export = create;

types/gl-vec2/cross.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Computes the cross product of two vec2's Note that the cross product must by definition produce a 3D vector.
+ */
+declare function cross(out: number[], a: number[], b: number[]): number[];
+
+export = cross;

types/gl-vec2/dist.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Calculates the euclidian distance between two vec2's. Aliased as dist.
+ */
+declare function dist(a: number[], b: number[]): number;
+
+export = dist;

types/gl-vec2/div.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Divides two vec2's. Aliased as div.
+ */
+declare function div(out: number[], a: number[], b: number[]): number[];
+
+export = div;

types/gl-vec2/dot.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Calculates the dot product of two vec2's.
+ */
+declare function dot(a: number[], b: number[]): number;
+
+export = dot;

types/gl-vec2/equals.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Returns whether or not the vectors have approximately the same elements in the same position.
+ */
+declare function equals(a: number[], b: number[]): boolean;
+
+export = equals;

types/gl-vec2/exactEquals.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Returns whether or not the vectors exactly have the same elements in the same position (when compared with ===).
+ */
+declare function exactEquals(a: number[], b: number[]): boolean;
+
+export = exactEquals;

types/gl-vec2/floor.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Math.floor the components of a vec2.
+ */
+declare function floor(out: number[], a: number[]): number[];
+
+export = floor;

types/gl-vec2/forEach.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Perform some operation over an array of vec2s.
+ */
+declare function forEach(a: number[], stride: number, offset: number, count: number, fn: (a: number[], b: number[], arg: object) => number[], arg: object): number[];
+
+export = forEach;

types/gl-vec2/fromValues.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Creates a new vec2 initialized with the given values.
+ */
+declare function fromValues(x: number, y: number): number[];
+
+export = fromValues;

types/gl-vec2/gl-vec2-tests.ts

@@ -0,0 +1,134 @@
+import GlVec2 = require("gl-vec2");
+
+import GlVec2Add = require("gl-vec2/add");
+import GlVec2Clone = require("gl-vec2/clone");
+import GlVec2Copy = require("gl-vec2/copy");
+import GlVec2Create = require("gl-vec2/create");
+import GlVec2Cross = require("gl-vec2/cross");
+import GlVec2Dist = require("gl-vec2/dist");
+import GlVec2Div = require("gl-vec2/div");
+import GlVec2Dot = require("gl-vec2/dot");
+import GlVec2Equals = require("gl-vec2/equals");
+import GlVec2exactEquals = require("gl-vec2/exactEquals");
+import GlVec2forEach = require("gl-vec2/forEach");
+import GlVec2fromValues = require("gl-vec2/fromValues");
+import GlVec2Floor = require("gl-vec2/floor");
+import GlVec2Inverse = require("gl-vec2/inverse");
+import GlVec2Len = require("gl-vec2/len");
+import GlVec2Lerp = require("gl-vec2/lerp");
+import GlVec2Limit = require("gl-vec2/limit");
+import GlVec2Max = require("gl-vec2/max");
+import GlVec2Min = require("gl-vec2/min");
+import GlVec2Mul = require("gl-vec2/mul");
+import GlVec2Negate = require("gl-vec2/negate");
+import GlVec2Normalize = require("gl-vec2/normalize");
+import GlVec2Random = require("gl-vec2/random");
+import GlVec2Scale = require("gl-vec2/scale");
+import GlVec2ScaleAndAdd = require("gl-vec2/scaleAndAdd");
+import GlVec2Set = require("gl-vec2/set");
+import GlVec2SqrDist = require("gl-vec2/sqrDist");
+import GlVec2SqrLen = require("gl-vec2/sqrLen");
+import GlVec2Sub = require("gl-vec2/sub");
+import GlVec2TransformMat2 = require("gl-vec2/transformMat2");
+import GlVec2TransformMat2d = require("gl-vec2/transformMat2d");
+import GlVec2TransformMat3 = require("gl-vec2/transformMat3");
+import GlVec2TransformMat4 = require("gl-vec2/transformMat4");
+
+GlVec2.add([1, 2, 3], [1, 2, 3], [1, 2, 3]);
+GlVec2Add([1, 2, 3], [1, 2, 3], [1, 2, 3]);
+
+GlVec2.clone([1, 2, 3]);
+GlVec2Clone([1, 2, 3]);
+
+GlVec2.copy([1, 2, 3], [1, 2, 3]);
+GlVec2Copy([1, 2, 3], [1, 2, 3]);
+
+GlVec2.create();
+GlVec2Create();
+
+GlVec2.cross([1, 2], [1, 2], [1, 2]);
+GlVec2Cross([1, 2], [1, 2], [1, 2]);
+
+GlVec2.dist([1, 2, 3], [1, 2, 3]);
+GlVec2Dist([1, 2, 3], [1, 2, 3]);
+
+GlVec2.div([1, 2, 3], [1, 2, 3], [1, 2, 3]);
+GlVec2Div([1, 2, 3], [1, 2, 3], [1, 2, 3]);
+
+GlVec2.dot([1, 2, 3], [1, 2, 3]);
+GlVec2Dot([1, 2, 3], [1, 2, 3]);
+
+GlVec2.forEach([1, 2, 3], 5, 6, 1, () => [3], {});
+GlVec2forEach([1, 2, 3], 5, 6, 1, () => [3], {});
+
+GlVec2.fromValues(1, 2);
+GlVec2fromValues(1, 2);
+
+GlVec2.floor([1, 2], [1, 2]);
+GlVec2Floor([1, 2], [1, 2]);
+
+GlVec2.equals([1, 2, 3], [1, 2, 3]);
+GlVec2Equals([1, 2, 3], [1, 2, 3]);
+
+GlVec2.exactEquals([1, 2, 3], [1, 2, 3]);
+GlVec2exactEquals([1, 2, 3], [1, 2, 3]);
+
+GlVec2.inverse([1, 2, 3], [1, 2, 3]);
+GlVec2Inverse([1, 2, 3], [1, 2, 3]);
+
+GlVec2.len([1, 2, 3]);
+GlVec2Len([1, 2, 3]);
+
+GlVec2.lerp([1, 2, 3], [1, 2, 3], [1, 2, 3], 6);
+GlVec2Lerp([1, 2, 3], [1, 2, 3], [1, 2, 3], 6);
+
+GlVec2.limit([1, 2], [1, 2], 5);
+GlVec2Limit([1, 2], [1, 2], 5);
+
+GlVec2.max([1, 2, 3], [1, 2, 3], [1, 2, 3]);
+GlVec2Max([1, 2, 3], [1, 2, 3], [1, 2, 3]);
+
+GlVec2.min([1, 2, 3], [1, 2, 3], [1, 2, 3]);
+GlVec2Min([1, 2, 3], [1, 2, 3], [1, 2, 3]);
+
+GlVec2.mul([1, 2, 3], [1, 2, 3], [1, 2, 3]);
+GlVec2Mul([1, 2, 3], [1, 2, 3], [1, 2, 3]);
+
+GlVec2.negate([1, 2, 3], [1, 2, 3]);
+GlVec2Negate([1, 2, 3], [1, 2, 3]);
+
+GlVec2.normalize([1, 2, 3], [1, 2, 3]);
+GlVec2Normalize([1, 2, 3], [1, 2, 3]);
+
+GlVec2.random([1, 2, 3], 6);
+GlVec2Random([1, 2, 3], 6);
+
+GlVec2.scale([1, 2, 3], [1, 2, 3], 6);
+GlVec2Scale([1, 2, 3], [1, 2, 3], 6);
+
+GlVec2.scaleAndAdd([1, 2, 3], [1, 2, 3], [1, 2, 3], 6);
+GlVec2ScaleAndAdd([1, 2, 3], [1, 2, 3], [1, 2, 3], 6);
+
+GlVec2.set([1, 2], 1, 2);
+GlVec2Set([1, 2], 1, 2);
+
+GlVec2.sqrDist([1, 2, 3], [1, 2, 3]);
+GlVec2SqrDist([1, 2, 3], [1, 2, 3]);
+
+GlVec2.sqrLen([1, 2, 3]);
+GlVec2SqrLen([1, 2, 3]);
+
+GlVec2.sub([1, 2, 3], [1, 2, 3], [1, 2, 3]);
+GlVec2Sub([1, 2, 3], [1, 2, 3], [1, 2, 3]);
+
+GlVec2.transformMat2([1, 2, 3], [1, 2, 3], [1, 2, 3]);
+GlVec2TransformMat2([1, 2, 3], [1, 2, 3], [1, 2, 3]);
+
+GlVec2.transformMat2([1, 2, 3], [1, 2, 3], [1, 2, 3]);
+GlVec2TransformMat2d([1, 2, 3], [1, 2, 3], [1, 2, 3]);
+
+GlVec2.transformMat3([1, 2, 3], [1, 2, 3], [1, 2, 3]);
+GlVec2TransformMat3([1, 2, 3], [1, 2, 3], [1, 2, 3]);
+
+GlVec2.transformMat4([1, 2, 3], [1, 2, 3], [1, 2, 3]);
+GlVec2TransformMat4([1, 2, 3], [1, 2, 3], [1, 2, 3]);

types/gl-vec2/index.d.ts

@@ -0,0 +1,75 @@
+// Type definitions for gl-vec2 1.3
+// Project: https://github.com/stackgl/gl-vec2
+// Definitions by:  Adam Zerella <https://github.com/adamzerella>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 3.3
+
+import add = require('./add');
+import clone = require('./clone');
+import copy = require('./copy');
+import create = require('./create');
+import cross = require('./cross');
+import dist = require('./dist');
+import div = require('./div');
+import dot = require('./dot');
+import equals = require('./equals');
+import exactEquals = require('./exactEquals');
+import floor = require('./floor');
+import forEach = require('./forEach');
+import fromValues = require('./fromValues');
+import inverse = require('./inverse');
+import len = require('./len');
+import lerp = require('./lerp');
+import limit = require('./limit');
+import max = require('./max');
+import min = require('./min');
+import mul = require('./mul');
+import negate = require('./negate');
+import normalize = require('./normalize');
+import random = require('./random');
+import scale = require('./scale');
+import scaleAndAdd = require('./scaleAndAdd');
+import set = require('./set');
+import sqrDist = require('./sqrDist');
+import sqrLen = require('./sqrLen');
+import sub = require('./sub');
+import transformMat2 = require('./transformMat2');
+import transformMat2d = require('./transformMat2d');
+import transformMat3 = require('./transformMat3');
+import transformMat4 = require('./transformMat4');
+
+export {
+    add,
+    clone,
+    copy,
+    create,
+    cross,
+    dist,
+    div,
+    dot,
+    equals,
+    exactEquals,
+    floor,
+    forEach,
+    fromValues,
+    inverse,
+    len,
+    lerp,
+    limit,
+    max,
+    min,
+    mul,
+    negate,
+    normalize,
+    random,
+    scale,
+    scaleAndAdd,
+    set,
+    sqrDist,
+    sqrLen,
+    sub,
+    transformMat2,
+    transformMat2d,
+    transformMat3,
+    transformMat4
+};

types/gl-vec2/inverse.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Returns the inverse of the components of a vec2.
+ */
+declare function inverse(out: number[], a: number[]): number[];
+
+export = inverse;

types/gl-vec2/len.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Calculates the length of a vec2. Aliased as len.
+ */
+declare  function len(a: number[]): number;
+
+export = len;

types/gl-vec2/lerp.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Performs a linear interpolation between two vec2's
+ */
+declare function lerp(out: number[], a: number[], b: number[], t: number): number[];
+
+export = lerp;

types/gl-vec2/limit.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Limit the magnitude of this vector to the value used for the max parameter.
+ */
+declare function limit(out: number[], a: number[], max: number): number[];
+
+export = limit;

types/gl-vec2/max.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Returns the maximum of two vec2's.
+ */
+declare function max(out: number[], a: number[], b: number[]): number[];
+
+export = max;

types/gl-vec2/min.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Returns the minimum of two vec2's.
+ */
+declare function min(out: number[], a: number[], b: number[]): number[];
+
+export = min;

types/gl-vec2/mul.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Multiplies two vec2's. Aliased as mul.
+ */
+declare function mul(out: number[], a: number[], b: number[]): number[];
+
+export = mul;

types/gl-vec2/negate.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Negates the components of a vec2.
+ */
+declare function negate(out: number[], a: number[]): number[];
+
+export = negate;

types/gl-vec2/normalize.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Normalize a number
+ */
+declare function normalize(out: number[], a: number[]): number[];
+
+export = normalize;

types/gl-vec2/random.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Generates a random vector with the given scale.
+ */
+declare function random(out: number[], scale: number): number[];
+
+export = random;

types/gl-vec2/scale.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Scales a vec2 by a scalar number.
+ */
+declare function scale(out: number[], a: number[], b: number): number[];
+
+export = scale;

types/gl-vec2/scaleAndAdd.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Adds two vec2's after scaling the second operand by a scalar value.
+ */
+declare function scaleAndAdd(out: number[], a: number[], b: number[], scale: number): number[];
+
+export = scaleAndAdd;

types/gl-vec2/set.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Set the components of a vec2 to the given values.
+ */
+declare function set(out: number[], x: number, y: number): number[];
+
+export = set;

types/gl-vec2/sqrDist.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Calculates the squared euclidian distance between two vec2's. Aliased as sqrDist.
+ */
+declare function sqrDist(a: number[], b: number[]): number[];
+
+export = sqrDist;

types/gl-vec2/sqrLen.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Calculates the squared length of a vec2. Aliased as sqrLen.
+ */
+declare function sqrLen(a: number[]): number[];
+
+export = sqrLen;

types/gl-vec2/sub.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Subtracts vector b from vector a. Aliased as sub.
+ */
+declare function sub(out: number[], a: number[], b: number[]): number[];
+
+export = sub;

types/gl-vec2/transformMat2.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Transforms the vec2 with a mat2.
+ */
+declare function transformMat2(out: number[], a: number[], m: number[]): number[];
+
+export = transformMat2;

types/gl-vec2/transformMat2d.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Transforms the vec with a mat2d.
+ */
+declare function transformMat2d(out: number[], a: number[], m: number[]): number[];
+
+export = transformMat2d;

types/gl-vec2/transformMat3.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Transforms the vec2 with a mat3 3rd vector component is implicitly '1'
+ */
+declare function transformMat3(out: number[], a: number[], m: number[]): number[];
+
+export = transformMat3;

types/gl-vec2/transformMat4.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Transforms the vec2 with a mat4 3rd vector component is implicitly '0' 4th vector component is implicitly '1'
+ */
+declare function transformMat4(out: number[], a: number[], m: number[]): number[];
+
+export = transformMat4;

types/gl-vec2/tsconfig.json

@@ -0,0 +1,58 @@
+{
+    "compilerOptions": {
+      "module": "commonjs",
+      "lib": [
+        "es6"
+      ],
+      "noImplicitAny": true,
+      "noImplicitThis": true,
+      "strictNullChecks": true,
+      "strictFunctionTypes": true,
+      "baseUrl": "../",
+      "typeRoots": [
+        "../"
+      ],
+      "types": [
+
+      ],
+      "noEmit": true,
+      "forceConsistentCasingInFileNames": true
+    },
+    "files": [
+      "index.d.ts",
+      "add.d.ts",
+      "clone.d.ts",
+      "copy.d.ts",
+      "create.d.ts",
+      "cross.d.ts",
+      "dist.d.ts",
+      "div.d.ts",
+      "dot.d.ts",
+      "equals.d.ts",
+      "exactEquals.d.ts",
+      "forEach.d.ts",
+      "fromValues.d.ts",
+      "floor.d.ts",
+      "inverse.d.ts",
+      "len.d.ts",
+      "lerp.d.ts",
+      "limit.d.ts",
+      "max.d.ts",
+      "min.d.ts",
+      "mul.d.ts",
+      "negate.d.ts",
+      "normalize.d.ts",
+      "random.d.ts",
+      "scale.d.ts",
+      "scaleAndAdd.d.ts",
+      "set.d.ts",
+      "sqrDist.d.ts",
+      "sqrLen.d.ts",
+      "sub.d.ts",
+      "transformMat2.d.ts",
+      "transformMat2d.d.ts",
+      "transformMat3.d.ts",
+      "transformMat4.d.ts",
+      "gl-vec2-tests.ts"
+    ]
+}

types/gl-vec2/tslint.json

@@ -0,0 +1,3 @@
+{
+    "extends": "dtslint/dt.json"
+}