mirror of
https://github.com/gosticks/DefinitelyTyped.git
synced 2026-08-12 04:50:18 +00:00
Merge pull request #10636 from MattijsKneppers/master
gl-matrix definitions update
This commit is contained in:
Andy
@@ -0,0 +1,362 @@
|
||||
/// <reference path="gl-matrix-legacy.d.ts" />
|
||||
|
||||
// common
|
||||
var result: number = glMatrix.toRadian(180);
|
||||
|
||||
var out: GLM.IArray;
|
||||
var outVal: number;
|
||||
var outStr: string;
|
||||
|
||||
// vec2
|
||||
var vecA: GLM.IArray, vecB: GLM.IArray, matA: GLM.IArray;
|
||||
var vecArray: GLM.IArray;
|
||||
|
||||
vecA = [1, 2];
|
||||
vecB = new Float32Array([3, 4]);
|
||||
out = [0, 0];
|
||||
matA = [1, 2, 3, 4, 5, 6];
|
||||
vecArray = [1, 2, 3, 4, 0, 0];
|
||||
|
||||
out = vec2.create();
|
||||
out = vec2.clone(vecA);
|
||||
out = vec2.fromValues(1, 2);
|
||||
out = vec2.copy(out, vecA);
|
||||
out = vec2.set(out, 1, 2);
|
||||
out = vec2.add(out, vecA, vecB);
|
||||
out = vec2.subtract(out, vecA, vecB);
|
||||
out = vec2.sub(out, vecA, vecB);
|
||||
out = vec2.multiply(out, vecA, vecB);
|
||||
out = vec2.mul(out, vecA, vecB);
|
||||
out = vec2.divide(out, vecA, vecB);
|
||||
out = vec2.div(out, vecA, vecB);
|
||||
out = vec2.min(out, vecA, vecB);
|
||||
out = vec2.max(out, vecA, vecB);
|
||||
out = vec2.scale(out, vecA, 2);
|
||||
out = vec2.scaleAndAdd(out, vecA, vecB, 0.5);
|
||||
outVal = vec2.distance(vecA, vecB);
|
||||
outVal = vec2.dist(vecA, vecB);
|
||||
outVal = vec2.squaredDistance(vecA, vecB);
|
||||
outVal = vec2.sqrDist(vecA, vecB);
|
||||
outVal = vec2.length(vecA);
|
||||
outVal = vec2.len(vecA);
|
||||
outVal = vec2.squaredLength(vecA);
|
||||
outVal = vec2.sqrLen(vecA);
|
||||
out = vec2.negate(out, vecA);
|
||||
out = vec2.inverse(out, vecA);
|
||||
out = vec2.normalize(out, vecA);
|
||||
outVal = vec2.dot(vecA, vecB);
|
||||
out = vec2.cross(out, vecA, vecB);
|
||||
out = vec2.lerp(out, vecA, vecB, 0.5);
|
||||
out = vec2.random(out);
|
||||
out = vec2.random(out, 5.0);
|
||||
out = vec2.transformMat2(out, vecA, matA);
|
||||
out = vec2.transformMat2d(out, vecA, matA);
|
||||
out = vec2.transformMat3(out, vecA, matA);
|
||||
out = vec2.transformMat4(out, vecA, matA);
|
||||
out = vec2.forEach(vecArray, 0, 0, 0, vec2.normalize);
|
||||
outStr = vec2.str(vecA);
|
||||
|
||||
// vec3
|
||||
var matr: GLM.IArray;
|
||||
var q: GLM.IArray;
|
||||
|
||||
vecA = [1, 2, 3];
|
||||
vecB = new Float32Array([4, 5, 6]);
|
||||
out = [0, 0, 0];
|
||||
vecArray = [1, 2, 3, 4, 5, 6, 0, 0, 0];
|
||||
matr = [1, 0, 0, 0, 1, 0, 0, 0, 1 ];
|
||||
|
||||
out = vec3.create();
|
||||
out = vec3.clone(vecA);
|
||||
out = vec3.fromValues(1, 2, 3);
|
||||
out = vec3.copy(out, vecA);
|
||||
out = vec3.set(out, 1, 2, 3);
|
||||
out = vec3.add(out, vecA, vecB);
|
||||
out = vec3.subtract(out, vecA, vecB);
|
||||
out = vec3.sub(out, vecA, vecB);
|
||||
out = vec3.multiply(out, vecA, vecB);
|
||||
out = vec3.mul(out, vecA, vecB);
|
||||
out = vec3.divide(out, vecA, vecB);
|
||||
out = vec3.div(out, vecA, vecB);
|
||||
out = vec3.min(out, vecA, vecB);
|
||||
out = vec3.max(out, vecA, vecB);
|
||||
out = vec3.scale(out, vecA, 2);
|
||||
out = vec3.scaleAndAdd(out, vecA, vecB, 0.5);
|
||||
outVal = vec3.distance(vecA, vecB);
|
||||
outVal = vec3.dist(vecA, vecB);
|
||||
outVal = vec3.squaredDistance(vecA, vecB);
|
||||
outVal = vec3.sqrDist(vecA, vecB);
|
||||
outVal = vec3.length(vecA);
|
||||
outVal = vec3.len(vecA);
|
||||
outVal = vec3.squaredLength(vecA);
|
||||
outVal = vec3.sqrLen(vecA);
|
||||
out = vec3.negate(out, vecA);
|
||||
out = vec3.inverse(out, vecA);
|
||||
out = vec3.normalize(out, vecA);
|
||||
outVal = vec3.dot(vecA, vecB);
|
||||
out = vec3.cross(out, vecA, vecB);
|
||||
out = vec3.lerp(out, vecA, vecB, 0.5);
|
||||
out = vec3.random(out);
|
||||
out = vec3.random(out, 5.0);
|
||||
out = vec3.rotateX(out, vecA, vecB, Math.PI);
|
||||
out = vec3.rotateY(out, vecA, vecB, Math.PI);
|
||||
out = vec3.rotateZ(out, vecA, vecB, Math.PI);
|
||||
out = vec3.transformMat3(out, vecA, matr);
|
||||
|
||||
matr = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1 ];
|
||||
out = vec3.transformMat4(out, vecA, matr);
|
||||
|
||||
q = [1, 2, 3, 4];
|
||||
out = vec3.transformQuat(out, vecA, matr);
|
||||
|
||||
out = vec3.forEach(vecArray, 0, 0, 0, vec3.normalize);
|
||||
outVal = vec3.angle(vecA, vecB);
|
||||
outStr = vec3.str(vecA);
|
||||
|
||||
// vec4
|
||||
var q: GLM.IArray;
|
||||
|
||||
vecA = [1, 2, 3, 4];
|
||||
vecB = new Float32Array([5, 6, 7, 8]);
|
||||
out = [0, 0, 0, 0];
|
||||
q = [1, 2, 3, 4];
|
||||
|
||||
out = vec4.create();
|
||||
out = vec4.clone(vecA);
|
||||
out = vec4.fromValues(1, 2, 3, 4);
|
||||
out = vec4.copy(out, vecA);
|
||||
out = vec4.set(out, 1, 2, 3, 4);
|
||||
out = vec4.add(out, vecA, vecB);
|
||||
out = vec4.subtract(out, vecA, vecB);
|
||||
out = vec4.sub(out, vecA, vecB);
|
||||
out = vec4.multiply(out, vecA, vecB);
|
||||
out = vec4.mul(out, vecA, vecB);
|
||||
out = vec4.divide(out, vecA, vecB);
|
||||
out = vec4.div(out, vecA, vecB);
|
||||
out = vec4.min(out, vecA, vecB);
|
||||
out = vec4.max(out, vecA, vecB);
|
||||
out = vec4.scale(out, vecA, 2);
|
||||
out = vec4.scaleAndAdd(out, vecA, vecB, 0.5);
|
||||
outVal = vec4.distance(vecA, vecB);
|
||||
outVal = vec4.dist(vecA, vecB);
|
||||
outVal = vec4.squaredDistance(vecA, vecB);
|
||||
outVal = vec4.sqrDist(vecA, vecB);
|
||||
outVal = vec4.length(vecA);
|
||||
outVal = vec4.len(vecA);
|
||||
outVal = vec4.squaredLength(vecA);
|
||||
outVal = vec4.sqrLen(vecA);
|
||||
out = vec4.negate(out, vecA);
|
||||
out = vec4.inverse(out, vecA);
|
||||
out = vec4.normalize(out, vecA);
|
||||
outVal = vec4.dot(vecA, vecB);
|
||||
out = vec4.lerp(out, vecA, vecB, 0.5);
|
||||
out = vec4.random(out);
|
||||
out = vec4.random(out, 5.0);
|
||||
|
||||
matr = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1 ]
|
||||
out = vec4.transformMat4(out, vecA, matr);
|
||||
out = vec4.transformQuat(out, vecA, q);
|
||||
|
||||
vecArray = [1, 2, 3, 4, 5, 6, 7, 8, 0, 0, 0, 0];
|
||||
out = vec4.forEach(vecArray, 0, 0, 0, vec4.normalize);
|
||||
outStr = vec4.str(vecA);
|
||||
|
||||
// mat2
|
||||
var matB: GLM.IArray, identity: GLM.IArray;
|
||||
|
||||
matA = [1, 2, 3, 4];
|
||||
matB = new Float32Array([5, 6, 7, 8]);
|
||||
out = [0, 0, 0, 0];
|
||||
identity = [1, 0, 0, 1];
|
||||
|
||||
out = mat2.create();
|
||||
out = mat2.clone(matA);
|
||||
out = mat2.copy(out, matA);
|
||||
out = mat2.identity(out);
|
||||
out = mat2.transpose(out, matA);
|
||||
out = mat2.invert(out, matA);
|
||||
out = mat2.adjoint(out, matA);
|
||||
outVal = mat2.determinant(matA);
|
||||
out = mat2.multiply(out, matA, matB);
|
||||
out = mat2.mul(out, matA, matB);
|
||||
out = mat2.rotate(out, matA, Math.PI * 0.5);
|
||||
|
||||
vecA = [2, 3];
|
||||
out = mat2.scale(out, matA, vecA);
|
||||
outStr = mat2.str(matA);
|
||||
outVal = mat2.frob(matA);
|
||||
|
||||
var L = mat2.create();
|
||||
var D = mat2.create();
|
||||
var U = mat2.create();
|
||||
out = mat2.LDU(L, D, U, [4,3,6,3]);
|
||||
|
||||
// mat2d
|
||||
matA = [1, 2, 3, 4, 5, 6];
|
||||
matB = [7, 8, 9, 10, 11, 12];
|
||||
out = [0, 0, 0, 0, 0, 0];
|
||||
identity = [1, 0, 0, 1, 0, 0];
|
||||
|
||||
out = mat2d.create();
|
||||
out = mat2d.clone(matA);
|
||||
out = mat2d.copy(out, matA);
|
||||
out = mat2d.identity(out);
|
||||
out = mat2d.invert(out, matA);
|
||||
outVal = mat2d.determinant(matA);
|
||||
out = mat2d.multiply(out, matA, matB);
|
||||
out = mat2d.mul(out, matA, matB);
|
||||
out = mat2d.rotate(out, matA, Math.PI * 0.5);
|
||||
|
||||
vecA = [2, 3];
|
||||
out = mat2d.scale(out, matA, vecA);
|
||||
out = mat2d.translate(out, matA, vecA);
|
||||
outStr = mat2d.str(matA);
|
||||
outVal = mat2d.frob(matA);
|
||||
|
||||
// mat3
|
||||
matA = [1, 0, 0, 0, 1, 0, 1, 2, 1];
|
||||
matB = [1, 0, 0, 0, 1, 0, 3, 4, 1];
|
||||
out = [0, 0, 0, 0, 0, 0, 0, 0, 0];
|
||||
identity = [1, 0, 0, 0, 1, 0, 0, 0, 1];
|
||||
|
||||
out = mat3.create();
|
||||
out = mat3.clone(matA);
|
||||
out = mat3.copy(out, matA);
|
||||
out = mat3.identity(out);
|
||||
out = mat3.transpose(out, matA);
|
||||
out = mat3.invert(out, matA);
|
||||
out = mat3.adjoint(out, matA);
|
||||
outVal = mat3.determinant(matA);
|
||||
out = mat3.multiply(out, matA, matB);
|
||||
out = mat3.mul(out, matA, matB);
|
||||
outStr = mat3.str(matA);
|
||||
outVal = mat3.frob(matA);
|
||||
|
||||
matA = [1, 0, 0, 0,
|
||||
0, 1, 0, 0,
|
||||
0, 0, 1, 0,
|
||||
0, 0, 0, 1];
|
||||
out = mat3.normalFromMat4(out, matA);
|
||||
|
||||
q = [ 0, -0.7071067811865475, 0, 0.7071067811865475 ];
|
||||
out = mat3.fromQuat(out, q);
|
||||
|
||||
out = mat3.normalFromMat4(out, [ 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12, 13,14,15,16]);
|
||||
out = mat3.fromMat4(out, [ 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12, 13,14,15,16]);
|
||||
out = mat3.scale(out, matA, [2,2]);
|
||||
out = mat3.fromMat2d(out, [1, 2, 3, 4, 5, 6]);
|
||||
|
||||
out = mat3.translate(out, matA, [1, 2, 3]);
|
||||
out = mat3.rotate(out, matA, Math.PI/2);
|
||||
|
||||
// mat4
|
||||
matA = [1, 0, 0, 0,
|
||||
0, 1, 0, 0,
|
||||
0, 0, 1, 0,
|
||||
1, 2, 3, 1];
|
||||
|
||||
matB = [1, 0, 0, 0,
|
||||
0, 1, 0, 0,
|
||||
0, 0, 1, 0,
|
||||
4, 5, 6, 1];
|
||||
|
||||
out = [0, 0, 0, 0,
|
||||
0, 0, 0, 0,
|
||||
0, 0, 0, 0,
|
||||
0, 0, 0, 0];
|
||||
|
||||
identity = [1, 0, 0, 0,
|
||||
0, 1, 0, 0,
|
||||
0, 0, 1, 0,
|
||||
0, 0, 0, 1];
|
||||
|
||||
out = mat4.create();
|
||||
out = mat4.clone(matA);
|
||||
out = mat4.copy(out, matA);
|
||||
out = mat4.identity(out);
|
||||
out = mat4.transpose(out, matA);
|
||||
out = mat4.invert(out, matA);
|
||||
out = mat4.adjoint(out, matA);
|
||||
outVal = mat4.determinant(matA);
|
||||
out = mat4.multiply(out, matA, matB);
|
||||
out = mat4.mul(out, matA, matB);
|
||||
out = mat4.translate(out, matA, [4, 5, 6]);
|
||||
out = mat4.scale(out, matA, [4, 5, 6]);
|
||||
|
||||
var rad = Math.PI * 0.5;
|
||||
var axis = [1, 0, 0];
|
||||
out = mat4.rotate(out, matA, rad, axis);
|
||||
out = mat4.rotateX(out, matA, rad);
|
||||
out = mat4.rotateY(out, matA, rad);
|
||||
out = mat4.rotateZ(out, matA, rad);
|
||||
|
||||
out = mat4.frustum(out, -1, 1, -1, 1, -1, 1);
|
||||
|
||||
var fovy = Math.PI * 0.5;
|
||||
out = mat4.perspective(out, fovy, 1, 0, 1);
|
||||
out = mat4.ortho(out, -1, 1, -1, 1, -1, 1);
|
||||
|
||||
var eye = [0, 0, 1];
|
||||
var center = [0, 0, -1];
|
||||
var up = [0, 1, 0];
|
||||
out = mat4.lookAt(out, eye, center, up);
|
||||
|
||||
outStr = mat4.str(matA);
|
||||
outVal = mat4.frob(matA);
|
||||
|
||||
q = [0, 0, 0, 1];
|
||||
out = mat4.fromRotationTranslation(out, q, [1, 2, 3]);
|
||||
out = mat4.fromQuat(out, q);
|
||||
|
||||
q = [0, 0, 0, 1];
|
||||
out = mat4.fromRotationTranslationScale(out, q, [1, 2, 3], [1, 2, 3]);
|
||||
out = mat4.fromQuat(out, q);
|
||||
|
||||
|
||||
// quat
|
||||
var quatA = [1, 2, 3, 4];
|
||||
var quatB = [5, 6, 7, 8];
|
||||
out = [0, 0, 0, 0];
|
||||
var vec = [1, 1, -1];
|
||||
var id = [0, 0, 0, 1];
|
||||
var deg90 = Math.PI / 2;
|
||||
|
||||
out = quat.create();
|
||||
out = quat.clone(quatA);
|
||||
out = quat.fromValues(1, 2, 3, 4);
|
||||
out = quat.copy(out, quatA);
|
||||
out = quat.set(out, 1, 2, 3, 4);
|
||||
out = quat.identity(out);
|
||||
out = quat.setAxisAngle(out, [1, 0, 0], Math.PI * 0.5);
|
||||
out = quat.add(out, quatA, quatB);
|
||||
out = quat.multiply(out, quatA, quatB);
|
||||
out = quat.mul(out, quatA, quatB);
|
||||
out = quat.scale(out, quatA, 2);
|
||||
outVal = quat.length(quatA);
|
||||
outVal = quat.len(quatA);
|
||||
outVal = quat.squaredLength(quatA);
|
||||
outVal = quat.sqrLen(quatA);
|
||||
out = quat.normalize(out, quatA);
|
||||
outVal = quat.dot(out, quatA, quatB);
|
||||
out = quat.lerp(out, quatA, quatB, 0.5);
|
||||
out = quat.slerp(out, quatA, quatB, 0.5);
|
||||
out = quat.invert(out, quatA);
|
||||
out = quat.conjugate(out, quatA);
|
||||
outStr = quat.str(quatA);
|
||||
out = quat.rotateX(out, id, deg90);
|
||||
out = quat.rotateY(out, id, deg90);
|
||||
out = quat.rotateZ(out, id, deg90);
|
||||
|
||||
matr = [ 1, 0, 0,
|
||||
0, 0, -1,
|
||||
0, 1, 0 ];
|
||||
out = quat.fromMat3(out, matr);
|
||||
|
||||
var view = [-1, 0, 0];
|
||||
up = [ 0, 1, 0];
|
||||
var right= [ 0, 0,-1];
|
||||
out = quat.setAxes([], view, right, up);
|
||||
|
||||
out = quat.rotationTo(out, [0, 1, 0], [1, 0, 0]);
|
||||
out = quat.calculateW(out, quatA);
|
||||
|
||||
Vendored
+2163
File diff suppressed because it is too large
Load Diff
+319
-334
@@ -1,362 +1,347 @@
|
||||
/// <reference path="gl-matrix.d.ts" />
|
||||
|
||||
// common
|
||||
var result: number = glMatrix.toRadian(180);
|
||||
import {vec2, mat2, mat3, mat4, vec3, vec4, mat2d, quat} from "./gl-matrix";
|
||||
|
||||
var out: GLM.IArray;
|
||||
var outVal: number;
|
||||
var outBool: boolean;
|
||||
var outStr: string;
|
||||
|
||||
let vecArray = new Float32Array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]);
|
||||
|
||||
let vec2A = vec2.fromValues(1, 2);
|
||||
let vec2B = vec2.fromValues(3, 4);
|
||||
let vec3A = vec3.fromValues(1, 2, 3);
|
||||
let vec3B = vec3.fromValues(3, 4, 5);
|
||||
let vec4A = vec4.fromValues(1, 2, 3, 4);
|
||||
let vec4B = vec4.fromValues(3, 4, 5, 6);
|
||||
let mat2A = mat2.fromValues(1, 2, 3, 4);
|
||||
let mat2B = mat2.fromValues(1, 2, 3, 4);
|
||||
let mat2dA = mat2d.fromValues(1, 2, 3, 4, 5, 6);
|
||||
let mat2dB = mat2d.fromValues(1, 2, 3, 4, 5, 6);
|
||||
let mat3A = mat3.fromValues(1, 2, 3, 4, 5, 6, 7, 8, 9);
|
||||
let mat3B = mat3.fromValues(1, 2, 3, 4, 5, 6, 7, 8, 9);
|
||||
let mat4A = mat4.fromValues(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
|
||||
let mat4B = mat4.fromValues(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
|
||||
let quatA = quat.fromValues(1, 2, 3, 4);
|
||||
let quatB = quat.fromValues(5, 6, 7, 8);
|
||||
|
||||
let outVec2 = vec2.create();
|
||||
let outVec3 = vec3.create();
|
||||
let outVec4 = vec4.create();
|
||||
let outMat2 = mat2.create();
|
||||
let outMat2d = mat2d.create();
|
||||
let outMat3 = mat3.create();
|
||||
let outMat4 = mat4.create();
|
||||
let outQuat = quat.create();
|
||||
|
||||
// vec2
|
||||
var vecA: GLM.IArray, vecB: GLM.IArray, matA: GLM.IArray;
|
||||
var vecArray: GLM.IArray;
|
||||
|
||||
vecA = [1, 2];
|
||||
vecB = new Float32Array([3, 4]);
|
||||
out = [0, 0];
|
||||
matA = [1, 2, 3, 4, 5, 6];
|
||||
vecArray = [1, 2, 3, 4, 0, 0];
|
||||
|
||||
out = vec2.create();
|
||||
out = vec2.clone(vecA);
|
||||
out = vec2.fromValues(1, 2);
|
||||
out = vec2.copy(out, vecA);
|
||||
out = vec2.set(out, 1, 2);
|
||||
out = vec2.add(out, vecA, vecB);
|
||||
out = vec2.subtract(out, vecA, vecB);
|
||||
out = vec2.sub(out, vecA, vecB);
|
||||
out = vec2.multiply(out, vecA, vecB);
|
||||
out = vec2.mul(out, vecA, vecB);
|
||||
out = vec2.divide(out, vecA, vecB);
|
||||
out = vec2.div(out, vecA, vecB);
|
||||
out = vec2.min(out, vecA, vecB);
|
||||
out = vec2.max(out, vecA, vecB);
|
||||
out = vec2.scale(out, vecA, 2);
|
||||
out = vec2.scaleAndAdd(out, vecA, vecB, 0.5);
|
||||
outVal = vec2.distance(vecA, vecB);
|
||||
outVal = vec2.dist(vecA, vecB);
|
||||
outVal = vec2.squaredDistance(vecA, vecB);
|
||||
outVal = vec2.sqrDist(vecA, vecB);
|
||||
outVal = vec2.length(vecA);
|
||||
outVal = vec2.len(vecA);
|
||||
outVal = vec2.squaredLength(vecA);
|
||||
outVal = vec2.sqrLen(vecA);
|
||||
out = vec2.negate(out, vecA);
|
||||
out = vec2.inverse(out, vecA);
|
||||
out = vec2.normalize(out, vecA);
|
||||
outVal = vec2.dot(vecA, vecB);
|
||||
out = vec2.cross(out, vecA, vecB);
|
||||
out = vec2.lerp(out, vecA, vecB, 0.5);
|
||||
out = vec2.random(out);
|
||||
out = vec2.random(out, 5.0);
|
||||
out = vec2.transformMat2(out, vecA, matA);
|
||||
out = vec2.transformMat2d(out, vecA, matA);
|
||||
out = vec2.transformMat3(out, vecA, matA);
|
||||
out = vec2.transformMat4(out, vecA, matA);
|
||||
out = vec2.forEach(vecArray, 0, 0, 0, vec2.normalize);
|
||||
outStr = vec2.str(vecA);
|
||||
outVec2 = vec2.create();
|
||||
outVec2 = vec2.clone(vec2A);
|
||||
outVec2 = vec2.fromValues(1, 2);
|
||||
outVec2 = vec2.copy(outVec2, vec2A);
|
||||
outVec2 = vec2.set(outVec2, 1, 2);
|
||||
outVec2 = vec2.add(outVec2, vec2A, vec2B);
|
||||
outVec2 = vec2.subtract(outVec2, vec2A, vec2B);
|
||||
outVec2 = vec2.sub(outVec2, vec2A, vec2B);
|
||||
outVec2 = vec2.multiply(outVec2, vec2A, vec2B);
|
||||
outVec2 = vec2.mul(outVec2, vec2A, vec2B);
|
||||
outVec2 = vec2.divide(outVec2, vec2A, vec2B);
|
||||
outVec2 = vec2.div(outVec2, vec2A, vec2B);
|
||||
outVec2 = vec2.ceil(outVec2, vec2A);
|
||||
outVec2 = vec2.floor(outVec2, vec2A);
|
||||
outVec2 = vec2.min(outVec2, vec2A, vec2B);
|
||||
outVec2 = vec2.max(outVec2, vec2A, vec2B);
|
||||
outVec2 = vec2.round(outVec2, vec2A);
|
||||
outVec2 = vec2.scale(outVec2, vec2A, 2);
|
||||
outVec2 = vec2.scaleAndAdd(outVec2, vec2A, vec2B, 0.5);
|
||||
outVal = vec2.distance(vec2A, vec2B);
|
||||
outVal = vec2.dist(vec2A, vec2B);
|
||||
outVal = vec2.squaredDistance(vec2A, vec2B);
|
||||
outVal = vec2.sqrDist(vec2A, vec2B);
|
||||
outVal = vec2.length(vec2A);
|
||||
outVal = vec2.len(vec2A);
|
||||
outVal = vec2.squaredLength(vec2A);
|
||||
outVal = vec2.sqrLen(vec2A);
|
||||
outVec2 = vec2.negate(outVec2, vec2A);
|
||||
outVec2 = vec2.inverse(outVec2, vec2A);
|
||||
outVec2 = vec2.normalize(outVec2, vec2A);
|
||||
outVal = vec2.dot(vec2A, vec2B);
|
||||
outVec2 = vec2.cross(outVec2, vec2A, vec2B);
|
||||
outVec2 = vec2.lerp(outVec2, vec2A, vec2B, 0.5);
|
||||
outVec2 = vec2.random(outVec2);
|
||||
outVec2 = vec2.random(outVec2, 5.0);
|
||||
outVec2 = vec2.transformMat2(outVec2, vec2A, mat2A);
|
||||
outVec2 = vec2.transformMat2d(outVec2, vec2A, mat2dA);
|
||||
outVec2 = vec2.transformMat3(outVec2, vec2A, mat3A);
|
||||
outVec2 = vec2.transformMat4(outVec2, vec2A, mat4A);
|
||||
vecArray = vec2.forEach(vecArray, 0, 0, 0, vec2.normalize);
|
||||
outStr = vec2.str(vec2A);
|
||||
outBool = vec2.exactEquals(vec2A, vec2B);
|
||||
outBool = vec2.equals(vec2A, vec2B);
|
||||
outVec2 = vec2.add(outVec2, [0, 1], [2, 3]); // test one method with number array input
|
||||
|
||||
// vec3
|
||||
var matr: GLM.IArray;
|
||||
var q: GLM.IArray;
|
||||
|
||||
vecA = [1, 2, 3];
|
||||
vecB = new Float32Array([4, 5, 6]);
|
||||
out = [0, 0, 0];
|
||||
vecArray = [1, 2, 3, 4, 5, 6, 0, 0, 0];
|
||||
matr = [1, 0, 0, 0, 1, 0, 0, 0, 1 ];
|
||||
|
||||
out = vec3.create();
|
||||
out = vec3.clone(vecA);
|
||||
out = vec3.fromValues(1, 2, 3);
|
||||
out = vec3.copy(out, vecA);
|
||||
out = vec3.set(out, 1, 2, 3);
|
||||
out = vec3.add(out, vecA, vecB);
|
||||
out = vec3.subtract(out, vecA, vecB);
|
||||
out = vec3.sub(out, vecA, vecB);
|
||||
out = vec3.multiply(out, vecA, vecB);
|
||||
out = vec3.mul(out, vecA, vecB);
|
||||
out = vec3.divide(out, vecA, vecB);
|
||||
out = vec3.div(out, vecA, vecB);
|
||||
out = vec3.min(out, vecA, vecB);
|
||||
out = vec3.max(out, vecA, vecB);
|
||||
out = vec3.scale(out, vecA, 2);
|
||||
out = vec3.scaleAndAdd(out, vecA, vecB, 0.5);
|
||||
outVal = vec3.distance(vecA, vecB);
|
||||
outVal = vec3.dist(vecA, vecB);
|
||||
outVal = vec3.squaredDistance(vecA, vecB);
|
||||
outVal = vec3.sqrDist(vecA, vecB);
|
||||
outVal = vec3.length(vecA);
|
||||
outVal = vec3.len(vecA);
|
||||
outVal = vec3.squaredLength(vecA);
|
||||
outVal = vec3.sqrLen(vecA);
|
||||
out = vec3.negate(out, vecA);
|
||||
out = vec3.inverse(out, vecA);
|
||||
out = vec3.normalize(out, vecA);
|
||||
outVal = vec3.dot(vecA, vecB);
|
||||
out = vec3.cross(out, vecA, vecB);
|
||||
out = vec3.lerp(out, vecA, vecB, 0.5);
|
||||
out = vec3.random(out);
|
||||
out = vec3.random(out, 5.0);
|
||||
out = vec3.rotateX(out, vecA, vecB, Math.PI);
|
||||
out = vec3.rotateY(out, vecA, vecB, Math.PI);
|
||||
out = vec3.rotateZ(out, vecA, vecB, Math.PI);
|
||||
out = vec3.transformMat3(out, vecA, matr);
|
||||
|
||||
matr = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1 ];
|
||||
out = vec3.transformMat4(out, vecA, matr);
|
||||
|
||||
q = [1, 2, 3, 4];
|
||||
out = vec3.transformQuat(out, vecA, matr);
|
||||
|
||||
out = vec3.forEach(vecArray, 0, 0, 0, vec3.normalize);
|
||||
outVal = vec3.angle(vecA, vecB);
|
||||
outStr = vec3.str(vecA);
|
||||
outVec3 = vec3.create();
|
||||
outVec3 = vec3.clone(vec3A);
|
||||
outVec3 = vec3.fromValues(1, 2, 3);
|
||||
outVec3 = vec3.copy(outVec3, vec3A);
|
||||
outVec3 = vec3.set(outVec3, 1, 2, 3);
|
||||
outVec3 = vec3.add(outVec3, vec3A, vec3B);
|
||||
outVec3 = vec3.subtract(outVec3, vec3A, vec3B);
|
||||
outVec3 = vec3.sub(outVec3, vec3A, vec3B);
|
||||
outVec3 = vec3.multiply(outVec3, vec3A, vec3B);
|
||||
outVec3 = vec3.mul(outVec3, vec3A, vec3B);
|
||||
outVec3 = vec3.divide(outVec3, vec3A, vec3B);
|
||||
outVec3 = vec3.div(outVec3, vec3A, vec3B);
|
||||
outVec3 = vec3.ceil(outVec3, vec3A);
|
||||
outVec3 = vec3.floor(outVec3, vec3A);
|
||||
outVec3 = vec3.min(outVec3, vec3A, vec3B);
|
||||
outVec3 = vec3.max(outVec3, vec3A, vec3B);
|
||||
outVec3 = vec3.round(outVec3, vec3A);
|
||||
outVec3 = vec3.scale(outVec3, vec3A, 2);
|
||||
outVec3 = vec3.scaleAndAdd(outVec3, vec3A, vec3B, 0.5);
|
||||
outVal = vec3.distance(vec3A, vec3B);
|
||||
outVal = vec3.dist(vec3A, vec3B);
|
||||
outVal = vec3.squaredDistance(vec3A, vec3B);
|
||||
outVal = vec3.sqrDist(vec3A, vec3B);
|
||||
outVal = vec3.length(vec3A);
|
||||
outVal = vec3.len(vec3A);
|
||||
outVal = vec3.squaredLength(vec3A);
|
||||
outVal = vec3.sqrLen(vec3A);
|
||||
outVec3 = vec3.negate(outVec3, vec3A);
|
||||
outVec3 = vec3.inverse(outVec3, vec3A);
|
||||
outVec3 = vec3.normalize(outVec3, vec3A);
|
||||
outVal = vec3.dot(vec3A, vec3B);
|
||||
outVec3 = vec3.cross(outVec3, vec3A, vec3B);
|
||||
outVec3 = vec3.lerp(outVec3, vec3A, vec3B, 0.5);
|
||||
outVec3 = vec3.hermite(outVec3, vec3A, vec3B, vec3A, vec3B, 0.5);
|
||||
outVec3 = vec3.bezier(outVec3, vec3A, vec3B, vec3A, vec3B, 0.5);
|
||||
outVec3 = vec3.random(outVec3);
|
||||
outVec3 = vec3.random(outVec3, 5.0);
|
||||
outVec3 = vec3.transformMat3(outVec3, vec3A, mat3A);
|
||||
outVec3 = vec3.transformMat4(outVec3, vec3A, mat4A);
|
||||
outVec3 = vec3.transformQuat(outVec3, vec3A, quatA);
|
||||
outVec3 = vec3.rotateX(outVec3, vec3A, vec3B, Math.PI);
|
||||
outVec3 = vec3.rotateY(outVec3, vec3A, vec3B, Math.PI);
|
||||
outVec3 = vec3.rotateZ(outVec3, vec3A, vec3B, Math.PI);
|
||||
vecArray = vec3.forEach(vecArray, 0, 0, 0, vec3.normalize);
|
||||
outVal = vec3.angle(vec3A, vec3B);
|
||||
outStr = vec3.str(vec3A);
|
||||
outBool = vec3.exactEquals(vec3A, vec3B);
|
||||
outBool = vec3.equals(vec3A, vec3B);
|
||||
outVec3 = vec3.add(outVec3, [0, 1, 2], [3, 4, 5]); // test one method with number array input
|
||||
|
||||
// vec4
|
||||
var q: GLM.IArray;
|
||||
|
||||
vecA = [1, 2, 3, 4];
|
||||
vecB = new Float32Array([5, 6, 7, 8]);
|
||||
out = [0, 0, 0, 0];
|
||||
q = [1, 2, 3, 4];
|
||||
|
||||
out = vec4.create();
|
||||
out = vec4.clone(vecA);
|
||||
out = vec4.fromValues(1, 2, 3, 4);
|
||||
out = vec4.copy(out, vecA);
|
||||
out = vec4.set(out, 1, 2, 3, 4);
|
||||
out = vec4.add(out, vecA, vecB);
|
||||
out = vec4.subtract(out, vecA, vecB);
|
||||
out = vec4.sub(out, vecA, vecB);
|
||||
out = vec4.multiply(out, vecA, vecB);
|
||||
out = vec4.mul(out, vecA, vecB);
|
||||
out = vec4.divide(out, vecA, vecB);
|
||||
out = vec4.div(out, vecA, vecB);
|
||||
out = vec4.min(out, vecA, vecB);
|
||||
out = vec4.max(out, vecA, vecB);
|
||||
out = vec4.scale(out, vecA, 2);
|
||||
out = vec4.scaleAndAdd(out, vecA, vecB, 0.5);
|
||||
outVal = vec4.distance(vecA, vecB);
|
||||
outVal = vec4.dist(vecA, vecB);
|
||||
outVal = vec4.squaredDistance(vecA, vecB);
|
||||
outVal = vec4.sqrDist(vecA, vecB);
|
||||
outVal = vec4.length(vecA);
|
||||
outVal = vec4.len(vecA);
|
||||
outVal = vec4.squaredLength(vecA);
|
||||
outVal = vec4.sqrLen(vecA);
|
||||
out = vec4.negate(out, vecA);
|
||||
out = vec4.inverse(out, vecA);
|
||||
out = vec4.normalize(out, vecA);
|
||||
outVal = vec4.dot(vecA, vecB);
|
||||
out = vec4.lerp(out, vecA, vecB, 0.5);
|
||||
out = vec4.random(out);
|
||||
out = vec4.random(out, 5.0);
|
||||
|
||||
matr = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1 ]
|
||||
out = vec4.transformMat4(out, vecA, matr);
|
||||
out = vec4.transformQuat(out, vecA, q);
|
||||
|
||||
vecArray = [1, 2, 3, 4, 5, 6, 7, 8, 0, 0, 0, 0];
|
||||
out = vec4.forEach(vecArray, 0, 0, 0, vec4.normalize);
|
||||
outStr = vec4.str(vecA);
|
||||
outVec4 = vec4.create();
|
||||
outVec4 = vec4.clone(vec4A);
|
||||
outVec4 = vec4.fromValues(1, 2, 3, 4);
|
||||
outVec4 = vec4.copy(outVec4, vec4A);
|
||||
outVec4 = vec4.set(outVec4, 1, 2, 3, 4);
|
||||
outVec4 = vec4.add(outVec4, vec4A, vec4B);
|
||||
outVec4 = vec4.subtract(outVec4, vec4A, vec4B);
|
||||
outVec4 = vec4.sub(outVec4, vec4A, vec4B);
|
||||
outVec4 = vec4.multiply(outVec4, vec4A, vec4B);
|
||||
outVec4 = vec4.mul(outVec4, vec4A, vec4B);
|
||||
outVec4 = vec4.divide(outVec4, vec4A, vec4B);
|
||||
outVec4 = vec4.div(outVec4, vec4A, vec4B);
|
||||
outVec4 = vec4.ceil(outVec4, vec4A);
|
||||
outVec4 = vec4.floor(outVec4, vec4A);
|
||||
outVec4 = vec4.min(outVec4, vec4A, vec4B);
|
||||
outVec4 = vec4.max(outVec4, vec4A, vec4B);
|
||||
outVec4 = vec4.scale(outVec4, vec4A, 2);
|
||||
outVec4 = vec4.scaleAndAdd(outVec4, vec4A, vec4B, 0.5);
|
||||
outVal = vec4.distance(vec4A, vec4B);
|
||||
outVal = vec4.dist(vec4A, vec4B);
|
||||
outVal = vec4.squaredDistance(vec4A, vec4B);
|
||||
outVal = vec4.sqrDist(vec4A, vec4B);
|
||||
outVal = vec4.length(vec4A);
|
||||
outVal = vec4.len(vec4A);
|
||||
outVal = vec4.squaredLength(vec4A);
|
||||
outVal = vec4.sqrLen(vec4A);
|
||||
outVec4 = vec4.negate(outVec4, vec4A);
|
||||
outVec4 = vec4.inverse(outVec4, vec4A);
|
||||
outVec4 = vec4.normalize(outVec4, vec4A);
|
||||
outVal = vec4.dot(vec4A, vec4B);
|
||||
outVec4 = vec4.lerp(outVec4, vec4A, vec4B, 0.5);
|
||||
outVec4 = vec4.random(outVec4);
|
||||
outVec4 = vec4.random(outVec4, 5.0);
|
||||
outVec4 = vec4.transformMat4(outVec4, vec4A, mat4A);
|
||||
outVec4 = vec4.transformQuat(outVec4, vec4A, quatA);
|
||||
vecArray = vec4.forEach(vecArray, 0, 0, 0, vec4.normalize);
|
||||
outStr = vec4.str(vec4A);
|
||||
outBool = vec4.exactEquals(vec4A, vec4B);
|
||||
outBool = vec4.equals(vec4A, vec4B);
|
||||
outVec4 = vec4.add(outVec4, [0, 1, 2, 3], [4, 5, 6, 7]); // test one method with number array input
|
||||
|
||||
// mat2
|
||||
var matB: GLM.IArray, identity: GLM.IArray;
|
||||
|
||||
matA = [1, 2, 3, 4];
|
||||
matB = new Float32Array([5, 6, 7, 8]);
|
||||
out = [0, 0, 0, 0];
|
||||
identity = [1, 0, 0, 1];
|
||||
|
||||
out = mat2.create();
|
||||
out = mat2.clone(matA);
|
||||
out = mat2.copy(out, matA);
|
||||
out = mat2.identity(out);
|
||||
out = mat2.transpose(out, matA);
|
||||
out = mat2.invert(out, matA);
|
||||
out = mat2.adjoint(out, matA);
|
||||
outVal = mat2.determinant(matA);
|
||||
out = mat2.multiply(out, matA, matB);
|
||||
out = mat2.mul(out, matA, matB);
|
||||
out = mat2.rotate(out, matA, Math.PI * 0.5);
|
||||
|
||||
vecA = [2, 3];
|
||||
out = mat2.scale(out, matA, vecA);
|
||||
outStr = mat2.str(matA);
|
||||
outVal = mat2.frob(matA);
|
||||
|
||||
var L = mat2.create();
|
||||
var D = mat2.create();
|
||||
outMat2 = mat2.create();
|
||||
outMat2 = mat2.clone(mat2A);
|
||||
outMat2 = mat2.copy(outMat2, mat2A);
|
||||
outMat2 = mat2.identity(outMat2);
|
||||
outMat2 = mat2.fromValues(1, 2, 3, 4);
|
||||
outMat2 = mat2.set(outMat2, 1, 2, 3, 4);
|
||||
outMat2 = mat2.transpose(outMat2, mat2A);
|
||||
outMat2 = mat2.invert(outMat2, mat2A);
|
||||
outMat2 = mat2.adjoint(outMat2, mat2A);
|
||||
outVal = mat2.determinant(mat2A);
|
||||
outMat2 = mat2.multiply(outMat2, mat2A, mat2B);
|
||||
outMat2 = mat2.mul(outMat2, mat2A, mat2B);
|
||||
outMat2 = mat2.rotate(outMat2, mat2A, Math.PI * 0.5);
|
||||
outMat2 = mat2.scale(outMat2, mat2A, vec2A);
|
||||
outMat2 = mat2.fromRotation(outMat2, 0.5);
|
||||
outMat2 = mat2.fromScaling(outMat2, vec2A);
|
||||
outStr = mat2.str(mat2A);
|
||||
outVal = mat2.frob(mat2A);
|
||||
var L = mat2.create();
|
||||
var D = mat2.create();
|
||||
var U = mat2.create();
|
||||
out = mat2.LDU(L, D, U, [4,3,6,3]);
|
||||
outMat2 = mat2.LDU(L, D, U, mat2A);
|
||||
outMat2 = mat2.add(outMat2, mat2A, mat2B);
|
||||
outMat2 = mat2.subtract(outMat2, mat2A, mat2B);
|
||||
outMat2 = mat2.sub(outMat2, mat2A, mat2B);
|
||||
outBool = mat2.exactEquals(mat2A, mat2B);
|
||||
outBool = mat2.equals(mat2A, mat2B);
|
||||
outMat2 = mat2.multiplyScalar (outMat2, mat2A, 2);
|
||||
outMat2 = mat2.multiplyScalarAndAdd (outMat2, mat2A, mat2B, 2);
|
||||
|
||||
// mat2d
|
||||
matA = [1, 2, 3, 4, 5, 6];
|
||||
matB = [7, 8, 9, 10, 11, 12];
|
||||
out = [0, 0, 0, 0, 0, 0];
|
||||
identity = [1, 0, 0, 1, 0, 0];
|
||||
|
||||
out = mat2d.create();
|
||||
out = mat2d.clone(matA);
|
||||
out = mat2d.copy(out, matA);
|
||||
out = mat2d.identity(out);
|
||||
out = mat2d.invert(out, matA);
|
||||
outVal = mat2d.determinant(matA);
|
||||
out = mat2d.multiply(out, matA, matB);
|
||||
out = mat2d.mul(out, matA, matB);
|
||||
out = mat2d.rotate(out, matA, Math.PI * 0.5);
|
||||
|
||||
vecA = [2, 3];
|
||||
out = mat2d.scale(out, matA, vecA);
|
||||
out = mat2d.translate(out, matA, vecA);
|
||||
outStr = mat2d.str(matA);
|
||||
outVal = mat2d.frob(matA);
|
||||
outMat2d = mat2d.create();
|
||||
outMat2d = mat2d.clone(mat2dA);
|
||||
outMat2d = mat2d.copy(outMat2d, mat2dA);
|
||||
outMat2d = mat2d.identity(outMat2d);
|
||||
outMat2d = mat2d.fromValues(1, 2, 3, 4, 5, 6);
|
||||
outMat2d = mat2d.set(outMat2d, 1, 2, 3, 4, 5, 6);
|
||||
outMat2d = mat2d.invert(outMat2d, mat2dA);
|
||||
outVal = mat2d.determinant(mat2dA);
|
||||
outMat2d = mat2d.multiply(outMat2d, mat2dA, mat2dB);
|
||||
outMat2d = mat2d.mul(outMat2d, mat2dA, mat2dB);
|
||||
outMat2d = mat2d.rotate(outMat2d, mat2dA, Math.PI * 0.5);
|
||||
outMat2d = mat2d.scale(outMat2d, mat2dA, vec2A);
|
||||
outMat2d = mat2d.translate(outMat2d, mat2dA, vec2A);
|
||||
outMat2d = mat2d.fromRotation(outMat2d, 0.5);
|
||||
outMat2d = mat2d.fromScaling(outMat2d, vec2A);
|
||||
outMat2d = mat2d.fromTranslation(outMat2d, vec2A);
|
||||
outStr = mat2d.str(mat2dA);
|
||||
outVal = mat2d.frob(mat2dA);
|
||||
outMat2d = mat2d.add(outMat2d, mat2dA, mat2dB);
|
||||
outMat2d = mat2d.subtract(outMat2d, mat2dA, mat2dB);
|
||||
outMat2d = mat2d.sub(outMat2d, mat2dA, mat2dB);
|
||||
outMat2d = mat2d.multiplyScalar (outMat2d, mat2dA, 2);
|
||||
outMat2d = mat2d.multiplyScalarAndAdd (outMat2d, mat2dA, mat2dB, 2);
|
||||
outBool = mat2d.exactEquals(mat2dA, mat2dB);
|
||||
outBool = mat2d.equals(mat2dA, mat2dB);
|
||||
|
||||
// mat3
|
||||
matA = [1, 0, 0, 0, 1, 0, 1, 2, 1];
|
||||
matB = [1, 0, 0, 0, 1, 0, 3, 4, 1];
|
||||
out = [0, 0, 0, 0, 0, 0, 0, 0, 0];
|
||||
identity = [1, 0, 0, 0, 1, 0, 0, 0, 1];
|
||||
|
||||
out = mat3.create();
|
||||
out = mat3.clone(matA);
|
||||
out = mat3.copy(out, matA);
|
||||
out = mat3.identity(out);
|
||||
out = mat3.transpose(out, matA);
|
||||
out = mat3.invert(out, matA);
|
||||
out = mat3.adjoint(out, matA);
|
||||
outVal = mat3.determinant(matA);
|
||||
out = mat3.multiply(out, matA, matB);
|
||||
out = mat3.mul(out, matA, matB);
|
||||
outStr = mat3.str(matA);
|
||||
outVal = mat3.frob(matA);
|
||||
|
||||
matA = [1, 0, 0, 0,
|
||||
0, 1, 0, 0,
|
||||
0, 0, 1, 0,
|
||||
0, 0, 0, 1];
|
||||
out = mat3.normalFromMat4(out, matA);
|
||||
|
||||
q = [ 0, -0.7071067811865475, 0, 0.7071067811865475 ];
|
||||
out = mat3.fromQuat(out, q);
|
||||
|
||||
out = mat3.normalFromMat4(out, [ 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12, 13,14,15,16]);
|
||||
out = mat3.fromMat4(out, [ 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12, 13,14,15,16]);
|
||||
out = mat3.scale(out, matA, [2,2]);
|
||||
out = mat3.fromMat2d(out, [1, 2, 3, 4, 5, 6]);
|
||||
|
||||
out = mat3.translate(out, matA, [1, 2, 3]);
|
||||
out = mat3.rotate(out, matA, Math.PI/2);
|
||||
|
||||
// mat4
|
||||
matA = [1, 0, 0, 0,
|
||||
0, 1, 0, 0,
|
||||
0, 0, 1, 0,
|
||||
1, 2, 3, 1];
|
||||
|
||||
matB = [1, 0, 0, 0,
|
||||
0, 1, 0, 0,
|
||||
0, 0, 1, 0,
|
||||
4, 5, 6, 1];
|
||||
|
||||
out = [0, 0, 0, 0,
|
||||
0, 0, 0, 0,
|
||||
0, 0, 0, 0,
|
||||
0, 0, 0, 0];
|
||||
|
||||
identity = [1, 0, 0, 0,
|
||||
0, 1, 0, 0,
|
||||
0, 0, 1, 0,
|
||||
0, 0, 0, 1];
|
||||
|
||||
out = mat4.create();
|
||||
out = mat4.clone(matA);
|
||||
out = mat4.copy(out, matA);
|
||||
out = mat4.identity(out);
|
||||
out = mat4.transpose(out, matA);
|
||||
out = mat4.invert(out, matA);
|
||||
out = mat4.adjoint(out, matA);
|
||||
outVal = mat4.determinant(matA);
|
||||
out = mat4.multiply(out, matA, matB);
|
||||
out = mat4.mul(out, matA, matB);
|
||||
out = mat4.translate(out, matA, [4, 5, 6]);
|
||||
out = mat4.scale(out, matA, [4, 5, 6]);
|
||||
|
||||
var rad = Math.PI * 0.5;
|
||||
var axis = [1, 0, 0];
|
||||
out = mat4.rotate(out, matA, rad, axis);
|
||||
out = mat4.rotateX(out, matA, rad);
|
||||
out = mat4.rotateY(out, matA, rad);
|
||||
out = mat4.rotateZ(out, matA, rad);
|
||||
|
||||
out = mat4.frustum(out, -1, 1, -1, 1, -1, 1);
|
||||
|
||||
var fovy = Math.PI * 0.5;
|
||||
out = mat4.perspective(out, fovy, 1, 0, 1);
|
||||
out = mat4.ortho(out, -1, 1, -1, 1, -1, 1);
|
||||
|
||||
var eye = [0, 0, 1];
|
||||
var center = [0, 0, -1];
|
||||
var up = [0, 1, 0];
|
||||
out = mat4.lookAt(out, eye, center, up);
|
||||
|
||||
outStr = mat4.str(matA);
|
||||
outVal = mat4.frob(matA);
|
||||
|
||||
q = [0, 0, 0, 1];
|
||||
out = mat4.fromRotationTranslation(out, q, [1, 2, 3]);
|
||||
out = mat4.fromQuat(out, q);
|
||||
|
||||
q = [0, 0, 0, 1];
|
||||
out = mat4.fromRotationTranslationScale(out, q, [1, 2, 3], [1, 2, 3]);
|
||||
out = mat4.fromQuat(out, q);
|
||||
outMat3 = mat3.create();
|
||||
outMat3 = mat3.fromMat4(outMat3, mat4A);
|
||||
outMat3 = mat3.clone(mat3A);
|
||||
outMat3 = mat3.copy(outMat3, mat3A);
|
||||
outMat3 = mat3.fromValues(1, 2, 3, 4, 5, 6, 7, 8, 9);
|
||||
outMat3 = mat3.set(outMat3, 1, 2, 3, 4, 5, 6, 7, 8, 9);
|
||||
outMat3 = mat3.identity(outMat3);
|
||||
outMat3 = mat3.transpose(outMat3, mat3A);
|
||||
outMat3 = mat3.invert(outMat3, mat3A);
|
||||
outMat3 = mat3.adjoint(outMat3, mat3A);
|
||||
outVal = mat3.determinant(mat3A);
|
||||
outMat3 = mat3.multiply(outMat3, mat3A, mat3B);
|
||||
outMat3 = mat3.mul(outMat3, mat3A, mat3B);
|
||||
outMat3 = mat3.translate(outMat3, mat3A, vec3A);
|
||||
outMat3 = mat3.rotate(outMat3, mat3A, Math.PI/2);
|
||||
outMat3 = mat3.scale(outMat3, mat3A, vec2A);
|
||||
outMat3 = mat3.fromTranslation(outMat3, vec2A);
|
||||
outMat3 = mat3.fromRotation(outMat3, Math.PI);
|
||||
outMat3 = mat3.fromScaling(outMat3, vec2A);
|
||||
outMat3 = mat3.fromMat2d(outMat3, mat2dA);
|
||||
outMat3 = mat3.fromQuat(outMat3, quatA);
|
||||
outMat3 = mat3.normalFromMat4(outMat3, mat4A);
|
||||
outStr = mat3.str(mat3A);
|
||||
outVal = mat3.frob(mat3A);
|
||||
outMat3 = mat3.add(outMat3, mat3A, mat3B);
|
||||
outMat3 = mat3.subtract(outMat3, mat3A, mat3B);
|
||||
outMat3 = mat3.sub(outMat3, mat3A, mat3B);
|
||||
outMat3 = mat3.multiplyScalar (outMat3, mat3A, 2);
|
||||
outMat3 = mat3.multiplyScalarAndAdd (outMat3, mat3A, mat3B, 2);
|
||||
outBool = mat3.exactEquals(mat3A, mat3B);
|
||||
outBool = mat3.equals(mat3A, mat3B);
|
||||
|
||||
//mat4
|
||||
outMat4 = mat4.create();
|
||||
outMat4 = mat4.clone(mat4A);
|
||||
outMat4 = mat4.copy(outMat4, mat4A);
|
||||
outMat4 = mat4.fromValues(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
|
||||
outMat4 = mat4.set(outMat4, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
|
||||
outMat4 = mat4.identity(outMat4);
|
||||
outMat4 = mat4.transpose(outMat4, mat4A);
|
||||
outMat4 = mat4.invert(outMat4, mat4A);
|
||||
outMat4 = mat4.adjoint(outMat4, mat4A);
|
||||
outVal = mat4.determinant(mat4A);
|
||||
outMat4 = mat4.multiply(outMat4, mat4A, mat4B);
|
||||
outMat4 = mat4.mul(outMat4, mat4A, mat4B);
|
||||
outMat4 = mat4.translate(outMat4, mat4A, vec3A);
|
||||
outMat4 = mat4.scale(outMat4, mat4A, vec3A);
|
||||
outMat4 = mat4.rotate(outMat4, mat4A, Math.PI, vec3A);
|
||||
outMat4 = mat4.rotateX(outMat4, mat4A, Math.PI);
|
||||
outMat4 = mat4.rotateY(outMat4, mat4A, Math.PI);
|
||||
outMat4 = mat4.rotateZ(outMat4, mat4A, Math.PI);
|
||||
outMat4 = mat4.fromTranslation(outMat4, vec3A);
|
||||
outMat4 = mat4.fromRotation(outMat4, Math.PI, vec3A);
|
||||
outMat4 = mat4.fromScaling(outMat4, vec3A);
|
||||
outMat4 = mat4.fromXRotation(outMat4, Math.PI);
|
||||
outMat4 = mat4.fromYRotation(outMat4, Math.PI);
|
||||
outMat4 = mat4.fromZRotation(outMat4, Math.PI);
|
||||
outMat4 = mat4.fromRotationTranslation(outMat4, quatA, vec3A);
|
||||
outVec3 = mat4.getTranslation(outVec3, mat4A)
|
||||
outQuat = mat4.getRotation(outQuat, mat4A)
|
||||
outMat4 = mat4.fromRotationTranslationScale(outMat4, quatA, vec3A, vec3B);
|
||||
outMat4 = mat4.fromRotationTranslationScaleOrigin(outMat4, quatA, vec3A, vec3B, vec3A);
|
||||
outMat4 = mat4.fromQuat(outMat4, quatB);
|
||||
outMat4 = mat4.frustum(outMat4, -1, 1, -1, 1, -1, 1);
|
||||
outMat4 = mat4.perspective(outMat4, Math.PI, 1, 0, 1);
|
||||
outMat4 = mat4.perspectiveFromFieldOfView(outMat4, {upDegrees:Math.PI, downDegrees:-Math.PI, leftDegrees:-Math.PI, rightDegrees:Math.PI}, 1, 0);
|
||||
outMat4 = mat4.ortho(outMat4, -1, 1, -1, 1, -1, 1);
|
||||
outMat4 = mat4.lookAt(outMat4, vec3A, vec3B, vec3A);
|
||||
outStr = mat4.str(mat4A);
|
||||
outVal = mat4.frob(mat4A);
|
||||
outMat4 = mat4.add(outMat4, mat4A, mat4B);
|
||||
outMat4 = mat4.subtract(outMat4, mat4A, mat4B);
|
||||
outMat4 = mat4.sub(outMat4, mat4A, mat4B);
|
||||
outMat4 = mat4.multiplyScalar (outMat4, mat4A, 2);
|
||||
outMat4 = mat4.multiplyScalarAndAdd (outMat4, mat4A, mat4B, 2);
|
||||
outBool = mat4.exactEquals(mat4A, mat4B);
|
||||
outBool = mat4.equals(mat4A, mat4B);
|
||||
|
||||
// quat
|
||||
var quatA = [1, 2, 3, 4];
|
||||
var quatB = [5, 6, 7, 8];
|
||||
out = [0, 0, 0, 0];
|
||||
var vec = [1, 1, -1];
|
||||
var id = [0, 0, 0, 1];
|
||||
var deg90 = Math.PI / 2;
|
||||
|
||||
out = quat.create();
|
||||
out = quat.clone(quatA);
|
||||
out = quat.fromValues(1, 2, 3, 4);
|
||||
out = quat.copy(out, quatA);
|
||||
out = quat.set(out, 1, 2, 3, 4);
|
||||
out = quat.identity(out);
|
||||
out = quat.setAxisAngle(out, [1, 0, 0], Math.PI * 0.5);
|
||||
out = quat.add(out, quatA, quatB);
|
||||
out = quat.multiply(out, quatA, quatB);
|
||||
out = quat.mul(out, quatA, quatB);
|
||||
out = quat.scale(out, quatA, 2);
|
||||
outQuat = quat.create();
|
||||
outQuat = quat.clone(quatA);
|
||||
outQuat = quat.fromValues(1, 2, 3, 4);
|
||||
outQuat = quat.copy(outQuat, quatA);
|
||||
outQuat = quat.set(outQuat, 1, 2, 3, 4);
|
||||
outQuat = quat.identity(outQuat);
|
||||
outQuat = quat.rotationTo(outQuat, vec3A, vec3B);
|
||||
outQuat = quat.setAxes(outQuat, vec3A, vec3B, vec3A);
|
||||
outQuat = quat.setAxisAngle(outQuat, vec3A, Math.PI * 0.5);
|
||||
outVal = quat.getAxisAngle (outVec3, quatA);
|
||||
outQuat = quat.add(outQuat, quatA, quatB);
|
||||
outQuat = quat.multiply(outQuat, quatA, quatB);
|
||||
outQuat = quat.mul(outQuat, quatA, quatB);
|
||||
outQuat = quat.scale(outQuat, quatA, 2);
|
||||
outVal = quat.length(quatA);
|
||||
outVal = quat.len(quatA);
|
||||
outVal = quat.squaredLength(quatA);
|
||||
outVal = quat.sqrLen(quatA);
|
||||
out = quat.normalize(out, quatA);
|
||||
outVal = quat.dot(out, quatA, quatB);
|
||||
out = quat.lerp(out, quatA, quatB, 0.5);
|
||||
out = quat.slerp(out, quatA, quatB, 0.5);
|
||||
out = quat.invert(out, quatA);
|
||||
out = quat.conjugate(out, quatA);
|
||||
outQuat = quat.normalize(outQuat, quatA);
|
||||
outVal = quat.dot(quatA, quatB);
|
||||
outQuat = quat.lerp(outQuat, quatA, quatB, 0.5);
|
||||
outQuat = quat.slerp(outQuat, quatA, quatB, 0.5);
|
||||
outQuat = quat.invert(outQuat, quatA);
|
||||
outQuat = quat.conjugate(outQuat, quatA);
|
||||
outStr = quat.str(quatA);
|
||||
out = quat.rotateX(out, id, deg90);
|
||||
out = quat.rotateY(out, id, deg90);
|
||||
out = quat.rotateZ(out, id, deg90);
|
||||
|
||||
matr = [ 1, 0, 0,
|
||||
0, 0, -1,
|
||||
0, 1, 0 ];
|
||||
out = quat.fromMat3(out, matr);
|
||||
|
||||
var view = [-1, 0, 0];
|
||||
up = [ 0, 1, 0];
|
||||
var right= [ 0, 0,-1];
|
||||
out = quat.setAxes([], view, right, up);
|
||||
|
||||
out = quat.rotationTo(out, [0, 1, 0], [1, 0, 0]);
|
||||
out = quat.calculateW(out, quatA);
|
||||
|
||||
outQuat = quat.rotateX(outQuat, quatA, deg90);
|
||||
outQuat = quat.rotateY(outQuat, quatA, deg90);
|
||||
outQuat = quat.rotateZ(outQuat, quatA, deg90);
|
||||
outQuat = quat.fromMat3(outQuat, mat3A);
|
||||
outQuat = quat.calculateW(outQuat, quatA);
|
||||
outBool = quat.exactEquals(quatA, quatB);
|
||||
outBool = quat.equals(quatA, quatB);
|
||||
|
||||
@@ -1,346 +0,0 @@
|
||||
/// <reference path="gl-matrix-typed.d.ts" />
|
||||
|
||||
// common
|
||||
import {vec2, mat2, mat3, mat4, vec3, vec4, glMatrix, mat2d, quat} from "./gl-matrix-typed";
|
||||
var result: number = glMatrix.toRadian(180);
|
||||
|
||||
var outVal: number;
|
||||
var outBool: boolean;
|
||||
var outStr: string;
|
||||
|
||||
let vecArray = new Float32Array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]);
|
||||
|
||||
let vec2A = vec2.fromValues(1, 2);
|
||||
let vec2B = vec2.fromValues(3, 4);
|
||||
let vec3A = vec3.fromValues(1, 2, 3);
|
||||
let vec3B = vec3.fromValues(3, 4, 5);
|
||||
let vec4A = vec4.fromValues(1, 2, 3, 4);
|
||||
let vec4B = vec4.fromValues(3, 4, 5, 6);
|
||||
let mat2A = mat2.fromValues(1, 2, 3, 4);
|
||||
let mat2B = mat2.fromValues(1, 2, 3, 4);
|
||||
let mat2dA = mat2d.fromValues(1, 2, 3, 4, 5, 6);
|
||||
let mat2dB = mat2d.fromValues(1, 2, 3, 4, 5, 6);
|
||||
let mat3A = mat3.fromValues(1, 2, 3, 4, 5, 6, 7, 8, 9);
|
||||
let mat3B = mat3.fromValues(1, 2, 3, 4, 5, 6, 7, 8, 9);
|
||||
let mat4A = mat4.fromValues(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
|
||||
let mat4B = mat4.fromValues(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
|
||||
let quatA = quat.fromValues(1, 2, 3, 4);
|
||||
let quatB = quat.fromValues(5, 6, 7, 8);
|
||||
|
||||
let outVec2 = vec2.create();
|
||||
let outVec3 = vec3.create();
|
||||
let outVec4 = vec4.create();
|
||||
let outMat2 = mat2.create();
|
||||
let outMat2d = mat2d.create();
|
||||
let outMat3 = mat3.create();
|
||||
let outMat4 = mat4.create();
|
||||
let outQuat = quat.create();
|
||||
|
||||
// vec2
|
||||
outVec2 = vec2.create();
|
||||
outVec2 = vec2.clone(vec2A);
|
||||
outVec2 = vec2.fromValues(1, 2);
|
||||
outVec2 = vec2.copy(outVec2, vec2A);
|
||||
outVec2 = vec2.set(outVec2, 1, 2);
|
||||
outVec2 = vec2.add(outVec2, vec2A, vec2B);
|
||||
outVec2 = vec2.subtract(outVec2, vec2A, vec2B);
|
||||
outVec2 = vec2.sub(outVec2, vec2A, vec2B);
|
||||
outVec2 = vec2.multiply(outVec2, vec2A, vec2B);
|
||||
outVec2 = vec2.mul(outVec2, vec2A, vec2B);
|
||||
outVec2 = vec2.divide(outVec2, vec2A, vec2B);
|
||||
outVec2 = vec2.div(outVec2, vec2A, vec2B);
|
||||
outVec2 = vec2.ceil(outVec2, vec2A);
|
||||
outVec2 = vec2.floor(outVec2, vec2A);
|
||||
outVec2 = vec2.min(outVec2, vec2A, vec2B);
|
||||
outVec2 = vec2.max(outVec2, vec2A, vec2B);
|
||||
outVec2 = vec2.round(outVec2, vec2A);
|
||||
outVec2 = vec2.scale(outVec2, vec2A, 2);
|
||||
outVec2 = vec2.scaleAndAdd(outVec2, vec2A, vec2B, 0.5);
|
||||
outVal = vec2.distance(vec2A, vec2B);
|
||||
outVal = vec2.dist(vec2A, vec2B);
|
||||
outVal = vec2.squaredDistance(vec2A, vec2B);
|
||||
outVal = vec2.sqrDist(vec2A, vec2B);
|
||||
outVal = vec2.length(vec2A);
|
||||
outVal = vec2.len(vec2A);
|
||||
outVal = vec2.squaredLength(vec2A);
|
||||
outVal = vec2.sqrLen(vec2A);
|
||||
outVec2 = vec2.negate(outVec2, vec2A);
|
||||
outVec2 = vec2.inverse(outVec2, vec2A);
|
||||
outVec2 = vec2.normalize(outVec2, vec2A);
|
||||
outVal = vec2.dot(vec2A, vec2B);
|
||||
outVec2 = vec2.cross(outVec2, vec2A, vec2B);
|
||||
outVec2 = vec2.lerp(outVec2, vec2A, vec2B, 0.5);
|
||||
outVec2 = vec2.random(outVec2);
|
||||
outVec2 = vec2.random(outVec2, 5.0);
|
||||
outVec2 = vec2.transformMat2(outVec2, vec2A, mat2A);
|
||||
outVec2 = vec2.transformMat2d(outVec2, vec2A, mat2dA);
|
||||
outVec2 = vec2.transformMat3(outVec2, vec2A, mat3A);
|
||||
outVec2 = vec2.transformMat4(outVec2, vec2A, mat4A);
|
||||
vecArray = vec2.forEach(vecArray, 0, 0, 0, vec2.normalize);
|
||||
outStr = vec2.str(vec2A);
|
||||
outBool = vec2.exactEquals(vec2A, vec2B);
|
||||
outBool = vec2.equals(vec2A, vec2B);
|
||||
|
||||
// vec3
|
||||
outVec3 = vec3.create();
|
||||
outVec3 = vec3.clone(vec3A);
|
||||
outVec3 = vec3.fromValues(1, 2, 3);
|
||||
outVec3 = vec3.copy(outVec3, vec3A);
|
||||
outVec3 = vec3.set(outVec3, 1, 2, 3);
|
||||
outVec3 = vec3.add(outVec3, vec3A, vec3B);
|
||||
outVec3 = vec3.subtract(outVec3, vec3A, vec3B);
|
||||
outVec3 = vec3.sub(outVec3, vec3A, vec3B);
|
||||
outVec3 = vec3.multiply(outVec3, vec3A, vec3B);
|
||||
outVec3 = vec3.mul(outVec3, vec3A, vec3B);
|
||||
outVec3 = vec3.divide(outVec3, vec3A, vec3B);
|
||||
outVec3 = vec3.div(outVec3, vec3A, vec3B);
|
||||
outVec3 = vec3.ceil(outVec3, vec3A);
|
||||
outVec3 = vec3.floor(outVec3, vec3A);
|
||||
outVec3 = vec3.min(outVec3, vec3A, vec3B);
|
||||
outVec3 = vec3.max(outVec3, vec3A, vec3B);
|
||||
outVec3 = vec3.round(outVec3, vec3A);
|
||||
outVec3 = vec3.scale(outVec3, vec3A, 2);
|
||||
outVec3 = vec3.scaleAndAdd(outVec3, vec3A, vec3B, 0.5);
|
||||
outVal = vec3.distance(vec3A, vec3B);
|
||||
outVal = vec3.dist(vec3A, vec3B);
|
||||
outVal = vec3.squaredDistance(vec3A, vec3B);
|
||||
outVal = vec3.sqrDist(vec3A, vec3B);
|
||||
outVal = vec3.length(vec3A);
|
||||
outVal = vec3.len(vec3A);
|
||||
outVal = vec3.squaredLength(vec3A);
|
||||
outVal = vec3.sqrLen(vec3A);
|
||||
outVec3 = vec3.negate(outVec3, vec3A);
|
||||
outVec3 = vec3.inverse(outVec3, vec3A);
|
||||
outVec3 = vec3.normalize(outVec3, vec3A);
|
||||
outVal = vec3.dot(vec3A, vec3B);
|
||||
outVec3 = vec3.cross(outVec3, vec3A, vec3B);
|
||||
outVec3 = vec3.lerp(outVec3, vec3A, vec3B, 0.5);
|
||||
outVec3 = vec3.hermite(outVec3, vec3A, vec3B, vec3A, vec3B, 0.5);
|
||||
outVec3 = vec3.bezier(outVec3, vec3A, vec3B, vec3A, vec3B, 0.5);
|
||||
outVec3 = vec3.random(outVec3);
|
||||
outVec3 = vec3.random(outVec3, 5.0);
|
||||
outVec3 = vec3.transformMat3(outVec3, vec3A, mat3A);
|
||||
outVec3 = vec3.transformMat4(outVec3, vec3A, mat4A);
|
||||
outVec3 = vec3.transformQuat(outVec3, vec3A, quatA);
|
||||
outVec3 = vec3.rotateX(outVec3, vec3A, vec3B, Math.PI);
|
||||
outVec3 = vec3.rotateY(outVec3, vec3A, vec3B, Math.PI);
|
||||
outVec3 = vec3.rotateZ(outVec3, vec3A, vec3B, Math.PI);
|
||||
vecArray = vec3.forEach(vecArray, 0, 0, 0, vec3.normalize);
|
||||
outVal = vec3.angle(vec3A, vec3B);
|
||||
outStr = vec3.str(vec3A);
|
||||
outBool = vec3.exactEquals(vec3A, vec3B);
|
||||
outBool = vec3.equals(vec3A, vec3B);
|
||||
|
||||
// vec4
|
||||
outVec4 = vec4.create();
|
||||
outVec4 = vec4.clone(vec4A);
|
||||
outVec4 = vec4.fromValues(1, 2, 3, 4);
|
||||
outVec4 = vec4.copy(outVec4, vec4A);
|
||||
outVec4 = vec4.set(outVec4, 1, 2, 3, 4);
|
||||
outVec4 = vec4.add(outVec4, vec4A, vec4B);
|
||||
outVec4 = vec4.subtract(outVec4, vec4A, vec4B);
|
||||
outVec4 = vec4.sub(outVec4, vec4A, vec4B);
|
||||
outVec4 = vec4.multiply(outVec4, vec4A, vec4B);
|
||||
outVec4 = vec4.mul(outVec4, vec4A, vec4B);
|
||||
outVec4 = vec4.divide(outVec4, vec4A, vec4B);
|
||||
outVec4 = vec4.div(outVec4, vec4A, vec4B);
|
||||
outVec4 = vec4.ceil(outVec4, vec4A);
|
||||
outVec4 = vec4.floor(outVec4, vec4A);
|
||||
outVec4 = vec4.min(outVec4, vec4A, vec4B);
|
||||
outVec4 = vec4.max(outVec4, vec4A, vec4B);
|
||||
outVec4 = vec4.scale(outVec4, vec4A, 2);
|
||||
outVec4 = vec4.scaleAndAdd(outVec4, vec4A, vec4B, 0.5);
|
||||
outVal = vec4.distance(vec4A, vec4B);
|
||||
outVal = vec4.dist(vec4A, vec4B);
|
||||
outVal = vec4.squaredDistance(vec4A, vec4B);
|
||||
outVal = vec4.sqrDist(vec4A, vec4B);
|
||||
outVal = vec4.length(vec4A);
|
||||
outVal = vec4.len(vec4A);
|
||||
outVal = vec4.squaredLength(vec4A);
|
||||
outVal = vec4.sqrLen(vec4A);
|
||||
outVec4 = vec4.negate(outVec4, vec4A);
|
||||
outVec4 = vec4.inverse(outVec4, vec4A);
|
||||
outVec4 = vec4.normalize(outVec4, vec4A);
|
||||
outVal = vec4.dot(vec4A, vec4B);
|
||||
outVec4 = vec4.lerp(outVec4, vec4A, vec4B, 0.5);
|
||||
outVec4 = vec4.random(outVec4);
|
||||
outVec4 = vec4.random(outVec4, 5.0);
|
||||
outVec4 = vec4.transformMat4(outVec4, vec4A, mat4A);
|
||||
outVec4 = vec4.transformQuat(outVec4, vec4A, quatA);
|
||||
vecArray = vec4.forEach(vecArray, 0, 0, 0, vec4.normalize);
|
||||
outStr = vec4.str(vec4A);
|
||||
outBool = vec4.exactEquals(vec4A, vec4B);
|
||||
outBool = vec4.equals(vec4A, vec4B);
|
||||
|
||||
// mat2
|
||||
outMat2 = mat2.create();
|
||||
outMat2 = mat2.clone(mat2A);
|
||||
outMat2 = mat2.copy(outMat2, mat2A);
|
||||
outMat2 = mat2.identity(outMat2);
|
||||
outMat2 = mat2.fromValues(1, 2, 3, 4);
|
||||
outMat2 = mat2.set(outMat2, 1, 2, 3, 4);
|
||||
outMat2 = mat2.transpose(outMat2, mat2A);
|
||||
outMat2 = mat2.invert(outMat2, mat2A);
|
||||
outMat2 = mat2.adjoint(outMat2, mat2A);
|
||||
outVal = mat2.determinant(mat2A);
|
||||
outMat2 = mat2.multiply(outMat2, mat2A, mat2B);
|
||||
outMat2 = mat2.mul(outMat2, mat2A, mat2B);
|
||||
outMat2 = mat2.rotate(outMat2, mat2A, Math.PI * 0.5);
|
||||
outMat2 = mat2.scale(outMat2, mat2A, vec2A);
|
||||
outMat2 = mat2.fromRotation(outMat2, 0.5);
|
||||
outMat2 = mat2.fromScaling(outMat2, vec2A);
|
||||
outStr = mat2.str(mat2A);
|
||||
outVal = mat2.frob(mat2A);
|
||||
var L = mat2.create();
|
||||
var D = mat2.create();
|
||||
var U = mat2.create();
|
||||
outMat2 = mat2.LDU(L, D, U, mat2A);
|
||||
outMat2 = mat2.add(outMat2, mat2A, mat2B);
|
||||
outMat2 = mat2.subtract(outMat2, mat2A, mat2B);
|
||||
outMat2 = mat2.sub(outMat2, mat2A, mat2B);
|
||||
outBool = mat2.exactEquals(mat2A, mat2B);
|
||||
outBool = mat2.equals(mat2A, mat2B);
|
||||
outMat2 = mat2.multiplyScalar (outMat2, mat2A, 2);
|
||||
outMat2 = mat2.multiplyScalarAndAdd (outMat2, mat2A, mat2B, 2);
|
||||
|
||||
// mat2d
|
||||
outMat2d = mat2d.create();
|
||||
outMat2d = mat2d.clone(mat2dA);
|
||||
outMat2d = mat2d.copy(outMat2d, mat2dA);
|
||||
outMat2d = mat2d.identity(outMat2d);
|
||||
outMat2d = mat2d.fromValues(1, 2, 3, 4, 5, 6);
|
||||
outMat2d = mat2d.set(outMat2d, 1, 2, 3, 4, 5, 6);
|
||||
outMat2d = mat2d.invert(outMat2d, mat2dA);
|
||||
outVal = mat2d.determinant(mat2dA);
|
||||
outMat2d = mat2d.multiply(outMat2d, mat2dA, mat2dB);
|
||||
outMat2d = mat2d.mul(outMat2d, mat2dA, mat2dB);
|
||||
outMat2d = mat2d.rotate(outMat2d, mat2dA, Math.PI * 0.5);
|
||||
outMat2d = mat2d.scale(outMat2d, mat2dA, vec2A);
|
||||
outMat2d = mat2d.translate(outMat2d, mat2dA, vec2A);
|
||||
outMat2d = mat2d.fromRotation(outMat2d, 0.5);
|
||||
outMat2d = mat2d.fromScaling(outMat2d, vec2A);
|
||||
outMat2d = mat2d.fromTranslation(outMat2d, vec2A);
|
||||
outStr = mat2d.str(mat2dA);
|
||||
outVal = mat2d.frob(mat2dA);
|
||||
outMat2d = mat2d.add(outMat2d, mat2dA, mat2dB);
|
||||
outMat2d = mat2d.subtract(outMat2d, mat2dA, mat2dB);
|
||||
outMat2d = mat2d.sub(outMat2d, mat2dA, mat2dB);
|
||||
outMat2d = mat2d.multiplyScalar (outMat2d, mat2dA, 2);
|
||||
outMat2d = mat2d.multiplyScalarAndAdd (outMat2d, mat2dA, mat2dB, 2);
|
||||
outBool = mat2d.exactEquals(mat2dA, mat2dB);
|
||||
outBool = mat2d.equals(mat2dA, mat2dB);
|
||||
|
||||
|
||||
// mat3
|
||||
outMat3 = mat3.create();
|
||||
outMat3 = mat3.fromMat4(outMat3, mat4A);
|
||||
outMat3 = mat3.clone(mat3A);
|
||||
outMat3 = mat3.copy(outMat3, mat3A);
|
||||
outMat3 = mat3.fromValues(1, 2, 3, 4, 5, 6, 7, 8, 9);
|
||||
outMat3 = mat3.set(outMat3, 1, 2, 3, 4, 5, 6, 7, 8, 9);
|
||||
outMat3 = mat3.identity(outMat3);
|
||||
outMat3 = mat3.transpose(outMat3, mat3A);
|
||||
outMat3 = mat3.invert(outMat3, mat3A);
|
||||
outMat3 = mat3.adjoint(outMat3, mat3A);
|
||||
outVal = mat3.determinant(mat3A);
|
||||
outMat3 = mat3.multiply(outMat3, mat3A, mat3B);
|
||||
outMat3 = mat3.mul(outMat3, mat3A, mat3B);
|
||||
outMat3 = mat3.translate(outMat3, mat3A, vec3A);
|
||||
outMat3 = mat3.rotate(outMat3, mat3A, Math.PI/2);
|
||||
outMat3 = mat3.scale(outMat3, mat3A, vec2A);
|
||||
outMat3 = mat3.fromTranslation(outMat3, vec2A);
|
||||
outMat3 = mat3.fromRotation(outMat3, Math.PI);
|
||||
outMat3 = mat3.fromScaling(outMat3, vec2A);
|
||||
outMat3 = mat3.fromMat2d(outMat3, mat2dA);
|
||||
outMat3 = mat3.fromQuat(outMat3, quatA);
|
||||
outMat3 = mat3.normalFromMat4(outMat3, mat4A);
|
||||
outStr = mat3.str(mat3A);
|
||||
outVal = mat3.frob(mat3A);
|
||||
outMat3 = mat3.add(outMat3, mat3A, mat3B);
|
||||
outMat3 = mat3.subtract(outMat3, mat3A, mat3B);
|
||||
outMat3 = mat3.sub(outMat3, mat3A, mat3B);
|
||||
outMat3 = mat3.multiplyScalar (outMat3, mat3A, 2);
|
||||
outMat3 = mat3.multiplyScalarAndAdd (outMat3, mat3A, mat3B, 2);
|
||||
outBool = mat3.exactEquals(mat3A, mat3B);
|
||||
outBool = mat3.equals(mat3A, mat3B);
|
||||
|
||||
//mat4
|
||||
outMat4 = mat4.create();
|
||||
outMat4 = mat4.clone(mat4A);
|
||||
outMat4 = mat4.copy(outMat4, mat4A);
|
||||
outMat4 = mat4.fromValues(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
|
||||
outMat4 = mat4.set(outMat4, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
|
||||
outMat4 = mat4.identity(outMat4);
|
||||
outMat4 = mat4.transpose(outMat4, mat4A);
|
||||
outMat4 = mat4.invert(outMat4, mat4A);
|
||||
outMat4 = mat4.adjoint(outMat4, mat4A);
|
||||
outVal = mat4.determinant(mat4A);
|
||||
outMat4 = mat4.multiply(outMat4, mat4A, mat4B);
|
||||
outMat4 = mat4.mul(outMat4, mat4A, mat4B);
|
||||
outMat4 = mat4.translate(outMat4, mat4A, vec3A);
|
||||
outMat4 = mat4.scale(outMat4, mat4A, vec3A);
|
||||
outMat4 = mat4.rotate(outMat4, mat4A, Math.PI, vec3A);
|
||||
outMat4 = mat4.rotateX(outMat4, mat4A, Math.PI);
|
||||
outMat4 = mat4.rotateY(outMat4, mat4A, Math.PI);
|
||||
outMat4 = mat4.rotateZ(outMat4, mat4A, Math.PI);
|
||||
outMat4 = mat4.fromTranslation(outMat4, vec3A);
|
||||
outMat4 = mat4.fromRotation(outMat4, Math.PI, vec3A);
|
||||
outMat4 = mat4.fromScaling(outMat4, vec3A);
|
||||
outMat4 = mat4.fromXRotation(outMat4, Math.PI);
|
||||
outMat4 = mat4.fromYRotation(outMat4, Math.PI);
|
||||
outMat4 = mat4.fromZRotation(outMat4, Math.PI);
|
||||
outMat4 = mat4.fromRotationTranslation(outMat4, quatA, vec3A);
|
||||
outVec3 = mat4.getTranslation(outVec3, mat4A)
|
||||
outQuat = mat4.getRotation(outQuat, mat4A)
|
||||
outMat4 = mat4.fromRotationTranslationScale(outMat4, quatA, vec3A, vec3B);
|
||||
outMat4 = mat4.fromRotationTranslationScaleOrigin(outMat4, quatA, vec3A, vec3B, vec3A);
|
||||
outMat4 = mat4.fromQuat(outMat4, quatB);
|
||||
outMat4 = mat4.frustum(outMat4, -1, 1, -1, 1, -1, 1);
|
||||
outMat4 = mat4.perspective(outMat4, Math.PI, 1, 0, 1);
|
||||
outMat4 = mat4.perspectiveFromFieldOfView(outMat4, {upDegrees:Math.PI, downDegrees:-Math.PI, leftDegrees:-Math.PI, rightDegrees:Math.PI}, 1, 0);
|
||||
outMat4 = mat4.ortho(outMat4, -1, 1, -1, 1, -1, 1);
|
||||
outMat4 = mat4.lookAt(outMat4, vec3A, vec3B, vec3A);
|
||||
outStr = mat4.str(mat4A);
|
||||
outVal = mat4.frob(mat4A);
|
||||
outMat4 = mat4.add(outMat4, mat4A, mat4B);
|
||||
outMat4 = mat4.subtract(outMat4, mat4A, mat4B);
|
||||
outMat4 = mat4.sub(outMat4, mat4A, mat4B);
|
||||
outMat4 = mat4.multiplyScalar (outMat4, mat4A, 2);
|
||||
outMat4 = mat4.multiplyScalarAndAdd (outMat4, mat4A, mat4B, 2);
|
||||
outBool = mat4.exactEquals(mat4A, mat4B);
|
||||
outBool = mat4.equals(mat4A, mat4B);
|
||||
|
||||
// quat
|
||||
var deg90 = Math.PI / 2;
|
||||
outQuat = quat.create();
|
||||
outQuat = quat.clone(quatA);
|
||||
outQuat = quat.fromValues(1, 2, 3, 4);
|
||||
outQuat = quat.copy(outQuat, quatA);
|
||||
outQuat = quat.set(outQuat, 1, 2, 3, 4);
|
||||
outQuat = quat.identity(outQuat);
|
||||
outQuat = quat.rotationTo(outQuat, vec3A, vec3B);
|
||||
outQuat = quat.setAxes(outQuat, vec3A, vec3B, vec3A);
|
||||
outQuat = quat.setAxisAngle(outQuat, vec3A, Math.PI * 0.5);
|
||||
outVal = quat.getAxisAngle (outVec3, quatA);
|
||||
outQuat = quat.add(outQuat, quatA, quatB);
|
||||
outQuat = quat.multiply(outQuat, quatA, quatB);
|
||||
outQuat = quat.mul(outQuat, quatA, quatB);
|
||||
outQuat = quat.scale(outQuat, quatA, 2);
|
||||
outVal = quat.length(quatA);
|
||||
outVal = quat.len(quatA);
|
||||
outVal = quat.squaredLength(quatA);
|
||||
outVal = quat.sqrLen(quatA);
|
||||
outQuat = quat.normalize(outQuat, quatA);
|
||||
outVal = quat.dot(quatA, quatB);
|
||||
outQuat = quat.lerp(outQuat, quatA, quatB, 0.5);
|
||||
outQuat = quat.slerp(outQuat, quatA, quatB, 0.5);
|
||||
outQuat = quat.invert(outQuat, quatA);
|
||||
outQuat = quat.conjugate(outQuat, quatA);
|
||||
outStr = quat.str(quatA);
|
||||
outQuat = quat.rotateX(outQuat, quatA, deg90);
|
||||
outQuat = quat.rotateY(outQuat, quatA, deg90);
|
||||
outQuat = quat.rotateZ(outQuat, quatA, deg90);
|
||||
outQuat = quat.fromMat3(outQuat, mat3A);
|
||||
outQuat = quat.calculateW(outQuat, quatA);
|
||||
outBool = quat.exactEquals(quatA, quatB);
|
||||
outBool = quat.equals(quatA, quatB);
|
||||
Vendored
-3054
File diff suppressed because it is too large
Load Diff
Vendored
+1289
-408
File diff suppressed because it is too large
Load Diff
Reference in New Issue
Block a user