Added type defs for gl-vec4

types/gl-vec4/gl-vec4-tests.ts

@@ -0,0 +1,27 @@
+import * as glVec from "gl-vec4";
+
+glVec.add([1, 2, 3], [1, 2, 3], [1, 2, 3]);
+glVec.clone([1, 2, 3]);
+glVec.copy([1, 2, 3], [1, 2, 3]);
+glVec.create();
+glVec.distance([1, 2, 3], [1, 2, 3]);
+glVec.divide([1, 2, 3], [1, 2, 3], [1, 2, 3]);
+glVec.dot([1, 2, 3], [1, 2, 3]);
+glVec.fromValues(6, 6, 6, 6);
+glVec.inverse([1, 2, 3], [1, 2, 3]);
+glVec.length([1, 2, 3]);
+glVec.lerp([1, 2, 3], [1, 2, 3], [1, 2, 3], 6);
+glVec.max([1, 2, 3], [1, 2, 3], [1, 2, 3]);
+glVec.min([1, 2, 3], [1, 2, 3], [1, 2, 3]);
+glVec.multiply([1, 2, 3], [1, 2, 3], [1, 2, 3]);
+glVec.negate([1, 2, 3], [1, 2, 3]);
+glVec.normalize([1, 2, 3], [1, 2, 3]);
+glVec.random([1, 2, 3], 6);
+glVec.scale([1, 2, 3], [1, 2, 3], 6);
+glVec.scaleAndAdd([1, 2, 3], [1, 2, 3], [1, 2, 3], 6);
+glVec.set([1, 2, 3], [1, 2, 3], [1, 2, 3], 6, 6);
+glVec.squaredDistance([1, 2, 3], [1, 2, 3]);
+glVec.squaredLength([1, 2, 3]);
+glVec.subtract([1, 2, 3], [1, 2, 3], [1, 2, 3]);
+glVec.transformMat4([1, 2, 3], [1, 2, 3], [1, 2, 3]);
+glVec.transformQuat([1, 2, 3], [1, 2, 3], [1, 2, 3]);

types/gl-vec4/index.d.ts

@@ -0,0 +1,130 @@
+// Type definitions for gl-vec4 1.0
+// Project: https://github.com/stackgl/gl-vec4
+// Definitions by:  Adam Zerella <https://github.com/adamzerella>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 3.3
+
+/**
+ * Adds two vec4's.
+ */
+export function add(out: number[], a: number[], b: number[]): number[];
+
+/**
+ * Creates a new vec4 initialized with values from an existing vector.
+ */
+export function clone(a: number[]): number[];
+
+/**
+ * Copy the values from one vec4 to another.
+ */
+export function copy(out: number[], a: number[]): number[];
+
+/**
+ * Creates a new, empty vec4.
+ */
+export function create(): number[];
+
+/**
+ * Calculates the euclidian distance between two vec4's.
+ */
+export function distance(a: number[], b: number[]): number[];
+
+/**
+ * Divides two vec4's.
+ */
+export function divide(out: number[], a: number[], b: number[]): number[];
+
+/**
+ * Calculates the dot product of two vec4's.
+ */
+export function dot(a: number[], b: number[]): number[];
+
+/**
+ * Creates a new vec4 initialized with the given values.
+ */
+export function fromValues(x: number, y: number, z: number, w: number): number[];
+
+/**
+ * Returns the inverse of the components of a vec4.
+ */
+export function inverse(out: number[], a: number[]): number[];
+
+/**
+ * Calculates the length of a vec4.
+ */
+export function length(a: number[]): number[];
+
+/**
+ * Performs a linear interpolation between two vec4's.
+ */
+export function lerp(out: number[], a: number[], b: number[], t: number): number[];
+
+/**
+ * Returns the maximum of two vec4's.
+ */
+export function max(out: number[], a: number[], b: number[]): number[];
+
+/**
+ * Returns the minimum of two vec4's.
+ */
+export function min(out: number[], a: number[], b: number[]): number[];
+
+/**
+ * Multiplies two vec4's.
+ */
+export function multiply(out: number[], a: number[], b: number[]): number[];
+
+/**
+ * Negates the components of a vec4.
+ */
+export function negate(out: number[], a: number[]): number[];
+
+/**
+ * Normalize a vec4.
+ */
+export function normalize(out: number[], a: number[]): number[];
+
+/**
+ * Generates a random vector with the given scale.
+ */
+export function random(out: number[], scale: number): number[];
+
+/**
+ * Scales a vec4 by a scalar number.
+ */
+export function scale(out: number[], a: number[], b: number): number[];
+
+/**
+ * Adds two vec4's after scaling the second operand by a scalar value.
+ */
+export function scaleAndAdd(out: number[], a: number[], b: number[], scale: number): number[];
+
+/**
+ * Set the components of a vec4 to the given values.
+ */
+export function set(out: number[], x: number[], y: number[], z: number, w: number): number[];
+
+/**
+ * Calculates the squared euclidian distance between two vec4's.
+ */
+export function squaredDistance(a: number[], b: number[]): number[];
+
+/**
+ * Calculates the squared length of a vec4.
+ */
+export function squaredLength(a: number[]): number[];
+
+/**
+ * Subtracts vector b from vector a.
+ */
+export function subtract(out: number[], a: number[], b: number[]): number[];
+
+/**
+ * Transforms the vec4 with a mat4..
+ */
+export function transformMat4(out: number[], a: number[], m: number[]): number[];
+
+/**
+ * Transforms the vec4 with a quat.
+ */
+export function transformQuat(out: number[], a: number[], q: number[]): number[];

types/gl-vec4/tsconfig.json

@@ -0,0 +1,25 @@
+{
+    "compilerOptions": {
+      "module": "commonjs",
+      "lib": [
+        "es6"
+      ],
+      "noImplicitAny": true,
+      "noImplicitThis": true,
+      "strictNullChecks": true,
+      "strictFunctionTypes": true,
+      "baseUrl": "../",
+      "typeRoots": [
+        "../"
+      ],
+      "types": [
+
+      ],
+      "noEmit": true,
+      "forceConsistentCasingInFileNames": true
+    },
+    "files": [
+      "index.d.ts",
+      "gl-vec4-tests.ts"
+    ]
+}

types/gl-vec4/tslint.json

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