480 lines
9.3 KiB
TypeScript
480 lines
9.3 KiB
TypeScript
/**
|
|
* @fileoverview TSM - A TypeScript vector and matrix math library
|
|
* @author Matthias Ferch
|
|
* @version 0.6
|
|
*/
|
|
|
|
/*
|
|
* Copyright (c) 2012 Matthias Ferch
|
|
*
|
|
* Project homepage: https://github.com/matthiasferch/tsm
|
|
*
|
|
* This software is provided 'as-is', without any express or implied
|
|
* warranty. In no event will the authors be held liable for any damages
|
|
* arising from the use of this software.
|
|
*
|
|
* Permission is granted to anyone to use this software for any purpose,
|
|
* including commercial applications, and to alter it and redistribute it
|
|
* freely, subject to the following restrictions:
|
|
*
|
|
* 1. The origin of this software must not be misrepresented; you must not
|
|
* claim that you wrote the original software. If you use this software
|
|
* in a product, an acknowledgment in the product documentation would be
|
|
* appreciated but is not required.
|
|
*
|
|
* 2. Altered source versions must be plainly marked as such, and must not
|
|
* be misrepresented as being the original software.
|
|
*
|
|
* 3. This notice may not be removed or altered from any source
|
|
* distribution.
|
|
*/
|
|
|
|
|
|
///<reference path='./common.ts' />
|
|
|
|
|
|
import { mat3 } from './mat3';
|
|
import { quat } from './quat';
|
|
|
|
export class vec3
|
|
{
|
|
static zero = new vec3([0, 0, 0]);
|
|
|
|
static up = new vec3([0, 1, 0]);
|
|
static right = new vec3([1, 0, 0]);
|
|
static forward = new vec3([0, 0, 1]);
|
|
|
|
private values = new Float32Array(3);
|
|
|
|
static cross(vector: vec3, vector2: vec3, dest: vec3 | null = null): vec3
|
|
{
|
|
if (!dest)
|
|
{
|
|
dest = new vec3();
|
|
}
|
|
|
|
const x = vector.x,
|
|
y = vector.y,
|
|
z = vector.z;
|
|
|
|
const x2 = vector2.x,
|
|
y2 = vector2.y,
|
|
z2 = vector2.z;
|
|
|
|
dest.x = y * z2 - z * y2;
|
|
dest.y = z * x2 - x * z2;
|
|
dest.z = x * y2 - y * x2;
|
|
|
|
return dest;
|
|
}
|
|
|
|
static dot(vector: vec3, vector2: vec3): number
|
|
{
|
|
const x = vector.x,
|
|
y = vector.y,
|
|
z = vector.z;
|
|
|
|
const x2 = vector2.x,
|
|
y2 = vector2.y,
|
|
z2 = vector2.z;
|
|
|
|
return (x * x2 + y * y2 + z * z2);
|
|
}
|
|
|
|
static distance(vector: vec3, vector2: vec3): number
|
|
{
|
|
const x = vector2.x - vector.x,
|
|
y = vector2.y - vector.y,
|
|
z = vector2.z - vector.z;
|
|
|
|
return Math.sqrt(this.squaredDistance(vector, vector2));
|
|
}
|
|
|
|
static squaredDistance(vector: vec3, vector2: vec3): number
|
|
{
|
|
const x = vector2.x - vector.x,
|
|
y = vector2.y - vector.y,
|
|
z = vector2.z - vector.z;
|
|
|
|
return (x * x + y * y + z * z);
|
|
}
|
|
|
|
static direction(vector: vec3, vector2: vec3, dest: vec3 | null = null): vec3
|
|
{
|
|
if (!dest)
|
|
{
|
|
dest = new vec3();
|
|
}
|
|
|
|
const x = vector.x - vector2.x,
|
|
y = vector.y - vector2.y,
|
|
z = vector.z - vector2.z;
|
|
|
|
let length = Math.sqrt(x * x + y * y + z * z);
|
|
|
|
if (length === 0)
|
|
{
|
|
dest.x = 0;
|
|
dest.y = 0;
|
|
dest.z = 0;
|
|
|
|
return dest;
|
|
}
|
|
|
|
length = 1 / length;
|
|
|
|
dest.x = x * length;
|
|
dest.y = y * length;
|
|
dest.z = z * length;
|
|
|
|
return dest;
|
|
}
|
|
|
|
static mix(vector: vec3, vector2: vec3, time: number, dest: vec3 | null = null): vec3
|
|
{
|
|
if (!dest)
|
|
{
|
|
dest = new vec3();
|
|
}
|
|
|
|
dest.x = vector.x + time * (vector2.x - vector.x);
|
|
dest.y = vector.y + time * (vector2.y - vector.y);
|
|
dest.z = vector.z + time * (vector2.z - vector.z);
|
|
|
|
return dest;
|
|
}
|
|
|
|
static sum(vector: vec3, vector2: vec3, dest: vec3 | null = null): vec3
|
|
{
|
|
if (!dest)
|
|
{
|
|
dest = new vec3();
|
|
}
|
|
|
|
dest.x = vector.x + vector2.x;
|
|
dest.y = vector.y + vector2.y;
|
|
dest.z = vector.z + vector2.z;
|
|
|
|
return dest;
|
|
}
|
|
|
|
static difference(vector: vec3, vector2: vec3, dest: vec3 | null = null): vec3
|
|
{
|
|
if (!dest)
|
|
{
|
|
dest = new vec3();
|
|
}
|
|
|
|
dest.x = vector.x - vector2.x;
|
|
dest.y = vector.y - vector2.y;
|
|
dest.z = vector.z - vector2.z;
|
|
|
|
return dest;
|
|
}
|
|
|
|
static product(vector: vec3, vector2: vec3, dest: vec3 | null = null): vec3
|
|
{
|
|
if (!dest)
|
|
{
|
|
dest = new vec3();
|
|
}
|
|
|
|
dest.x = vector.x * vector2.x;
|
|
dest.y = vector.y * vector2.y;
|
|
dest.z = vector.z * vector2.z;
|
|
|
|
return dest;
|
|
}
|
|
|
|
static quotient(vector: vec3, vector2: vec3, dest: vec3 | null = null): vec3
|
|
{
|
|
if (!dest)
|
|
{
|
|
dest = new vec3();
|
|
}
|
|
|
|
dest.x = vector.x / vector2.x;
|
|
dest.y = vector.y / vector2.y;
|
|
dest.z = vector.z / vector2.z;
|
|
|
|
return dest;
|
|
}
|
|
|
|
|
|
|
|
get x(): number
|
|
{
|
|
return this.values[0];
|
|
}
|
|
|
|
get y(): number
|
|
{
|
|
return this.values[1];
|
|
}
|
|
|
|
get z(): number
|
|
{
|
|
return this.values[2];
|
|
}
|
|
|
|
get xy(): number[]
|
|
{
|
|
return [
|
|
this.values[0],
|
|
this.values[1]
|
|
];
|
|
}
|
|
|
|
get xyz(): number[]
|
|
{
|
|
return [
|
|
this.values[0],
|
|
this.values[1],
|
|
this.values[2]
|
|
];
|
|
}
|
|
|
|
set x(value: number)
|
|
{
|
|
this.values[0] = value;
|
|
}
|
|
|
|
set y(value: number)
|
|
{
|
|
this.values[1] = value;
|
|
}
|
|
|
|
set z(value: number)
|
|
{
|
|
this.values[2] = value;
|
|
}
|
|
|
|
set xy(values: number[])
|
|
{
|
|
this.values[0] = values[0];
|
|
this.values[1] = values[1];
|
|
}
|
|
|
|
set xyz(values: number[])
|
|
{
|
|
this.values[0] = values[0];
|
|
this.values[1] = values[1];
|
|
this.values[2] = values[2];
|
|
}
|
|
|
|
constructor(values: number[] | null = null)
|
|
{
|
|
if (values)
|
|
{
|
|
this.xyz = values;
|
|
}
|
|
}
|
|
|
|
at(index: number): number
|
|
{
|
|
return this.values[index];
|
|
}
|
|
|
|
reset(): void
|
|
{
|
|
this.x = 0;
|
|
this.y = 0;
|
|
this.z = 0;
|
|
}
|
|
|
|
copy(dest: vec3 | null = null): vec3
|
|
{
|
|
if (!dest)
|
|
{
|
|
dest = new vec3();
|
|
}
|
|
|
|
dest.x = this.x;
|
|
dest.y = this.y;
|
|
dest.z = this.z;
|
|
|
|
return dest;
|
|
}
|
|
|
|
negate(dest: vec3 | null = null): vec3
|
|
{
|
|
if (!dest)
|
|
{
|
|
dest = this;
|
|
}
|
|
|
|
dest.x = -this.x;
|
|
dest.y = -this.y;
|
|
dest.z = -this.z;
|
|
|
|
return dest;
|
|
}
|
|
|
|
equals(vector: vec3, threshold = EPSILON): boolean
|
|
{
|
|
if (Math.abs(this.x - vector.x) > threshold)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (Math.abs(this.y - vector.y) > threshold)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (Math.abs(this.z - vector.z) > threshold)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
|
|
return true;
|
|
}
|
|
|
|
length(): number
|
|
{
|
|
return Math.sqrt(this.squaredLength());
|
|
}
|
|
|
|
squaredLength(): number
|
|
{
|
|
const x = this.x,
|
|
y = this.y,
|
|
z = this.z;
|
|
|
|
return (x * x + y * y + z * z);
|
|
}
|
|
|
|
add(vector: vec3): vec3
|
|
{
|
|
this.x += vector.x;
|
|
this.y += vector.y;
|
|
this.z += vector.z;
|
|
|
|
return this;
|
|
}
|
|
|
|
subtract(vector: vec3): vec3
|
|
{
|
|
this.x -= vector.x;
|
|
this.y -= vector.y;
|
|
this.z -= vector.z;
|
|
|
|
return this;
|
|
}
|
|
|
|
multiply(vector: vec3): vec3
|
|
{
|
|
this.x *= vector.x;
|
|
this.y *= vector.y;
|
|
this.z *= vector.z;
|
|
|
|
return this;
|
|
}
|
|
|
|
divide(vector: vec3): vec3
|
|
{
|
|
this.x /= vector.x;
|
|
this.y /= vector.y;
|
|
this.z /= vector.z;
|
|
|
|
return this;
|
|
}
|
|
|
|
scale(value: number, dest: vec3 | null = null): vec3
|
|
{
|
|
if (!dest)
|
|
{
|
|
dest = this;
|
|
}
|
|
|
|
dest.x *= value;
|
|
dest.y *= value;
|
|
dest.z *= value;
|
|
|
|
return dest;
|
|
}
|
|
|
|
normalize(dest: vec3 | null = null): vec3
|
|
{
|
|
if (!dest)
|
|
{
|
|
dest = this;
|
|
}
|
|
|
|
let length = this.length();
|
|
|
|
if (length === 1)
|
|
{
|
|
return this;
|
|
}
|
|
|
|
if (length === 0)
|
|
{
|
|
dest.x = 0;
|
|
dest.y = 0;
|
|
dest.z = 0;
|
|
|
|
return dest;
|
|
}
|
|
|
|
length = 1.0 / length;
|
|
|
|
dest.x *= length;
|
|
dest.y *= length;
|
|
dest.z *= length;
|
|
|
|
return dest;
|
|
}
|
|
|
|
multiplyByMat3(matrix: mat3, dest: vec3 | null = null): vec3
|
|
{
|
|
if (!dest)
|
|
{
|
|
dest = this;
|
|
}
|
|
|
|
return matrix.multiplyVec3(this, dest);
|
|
}
|
|
|
|
multiplyByQuat(quat: quat, dest: vec3 | null = null): vec3
|
|
{
|
|
if (!dest)
|
|
{
|
|
dest = this;
|
|
}
|
|
|
|
return quat.multiplyVec3(this, dest);
|
|
}
|
|
|
|
toQuat(dest: quat | null = null): quat
|
|
{
|
|
if (!dest)
|
|
{
|
|
dest = new quat();
|
|
}
|
|
|
|
const c = new vec3();
|
|
const s = new vec3();
|
|
|
|
c.x = Math.cos(this.x * 0.5);
|
|
s.x = Math.sin(this.x * 0.5);
|
|
|
|
c.y = Math.cos(this.y * 0.5);
|
|
s.y = Math.sin(this.y * 0.5);
|
|
|
|
c.z = Math.cos(this.z * 0.5);
|
|
s.z = Math.sin(this.z * 0.5);
|
|
|
|
dest.x = s.x * c.y * c.z - c.x * s.y * s.z;
|
|
dest.y = c.x * s.y * c.z + s.x * c.y * s.z;
|
|
dest.z = c.x * c.y * s.z - s.x * s.y * c.z;
|
|
dest.w = c.x * c.y * c.z + s.x * s.y * s.z;
|
|
|
|
return dest;
|
|
}
|
|
}
|
|
|
|
|
|
|