improve nw4r/math/types.VEC3

Author: yomcube

RVLTS/nw4r/math/types.ts

@@ -63,10 +63,12 @@ export class VEC3 implements _VEC3 {
 	y: number;
 	z: number;
 
-	constructor(fx: number, fy: number, fz: number) {
-		this.x = fx;
-		this.y = fy;
-		this.z = fz;
+	constructor()
+	constructor(fx: number, fy: number, fz: number)
+	constructor(fx?: number, fy?: number, fz?: number) {
+		this.x = fx == undefined ? 0 : fx;
+		this.y = fy == undefined ? 0 : fy;
+		this.z = fz == undefined ? 0 : fz;
 	}
 
 	/** Squared length of the vector. */
@@ -81,70 +83,52 @@ export class VEC3 implements _VEC3 {
 
 	/** + operator */
 	__plus(val: VEC3): VEC3 {
-		return new VEC3(
-			this.x + val.x,
-			this.y + val.y,
-			this.z + val.z
-		);
+		let out: VEC3 = new VEC3();
+		VEC3.add(out, this, val);
+		return out;
 	}
 
 	/** - operator */
 	__minus(val: VEC3): VEC3 {
-		return new VEC3(
-			this.x - val.x,
-			this.y - val.y,
-			this.z - val.z
-		);
+		let out: VEC3 = new VEC3();
+		VEC3.sub(out, this, val);
+		return out;
 	}
 
 	/** * operator */
-	__multiply(val: VEC3): VEC3 {
-		return new VEC3(
-			this.x * val.x,
-			this.y * val.y,
-			this.z * val.z
-		);
+	__multiply(val: number): VEC3 {
+		let out: VEC3 = new VEC3();
+		VEC3.scale(out, this, val);
+		return out;
 	}
 
 	/** / operator */
-	__divide(val: VEC3): VEC3 {
-		return new VEC3(
-			this.x / val.x,
-			this.y / val.y,
-			this.z / val.z
-		);
+	__divide(val: number): VEC3 {
+		let r: number = 1 / val;
+		return this.__multiply(r);
 	}
 
 	/** += operator */
 	__addAssign(val: VEC3): VEC3 {
-		this.x += val.x;
-		this.y += val.y;
-		this.z += val.z;
+		VEC3.add(this, this, val);
 		return this;
 	}
 
 	/** += operator */
 	__minusAssign(val: VEC3): VEC3 {
-		this.x -= val.x;
-		this.y -= val.y;
-		this.z -= val.z;
+		VEC3.sub(this, this, val);
 		return this;
 	}
 
 	/** *= operator */
-	__multiplyAssign(val: VEC3): VEC3 {
-		this.x *= val.x;
-		this.y *= val.y;
-		this.z *= val.z;
+	__multiplyAssign(val: number): VEC3 {
+		VEC3.scale(this, this, val);
 		return this;
 	}
 
 	/** /= operator */
-	__divideAssign(val: VEC3): VEC3 {
-		this.x /= val.x;
-		this.y /= val.y;
-		this.z /= val.z;
-		return this;
+	__divideAssign(val: number): VEC3 {
+		return this.__multiplyAssign(1 / val);
 	}
 
 	/** == operator */
@@ -166,20 +150,41 @@ export class VEC3 implements _VEC3 {
 	}
 
 	/** Dot product of two 3-dimensional vectors. */
-	static dot(vec1: VEC3, vec2: VEC3): number {
+	static dot(v1: VEC3, v2: VEC3): number {
 		return (
-			vec1.x * vec2.x +
-			vec1.y * vec2.y +
-			vec1.z * vec2.z
+			v1.x * v2.x +
+			v1.y * v2.y +
+			v1.z * v2.z
 		);
 	}
 
 	/** Linear interpolation of two 3-dimensional vectors. */
-	static lerp(vec1: VEC3, vec2, VEC3, t: number) {
+	static lerp(v1: VEC3, v2, VEC3, t: number) {
 		return new VEC3(
-			(vec2.x - vec1.x) * t + vec1.x,
-			(vec2.y - vec1.y) * t + vec1.y,
-			(vec2.z - vec1.z) * t + vec1.z,
+			(v2.x - v1.x) * t + v1.x,
+			(v2.y - v1.y) * t + v1.y,
+			(v2.z - v1.z) * t + v1.z,
 		);
 	}
+
+	/** Addition of two 3-dimensional vectors. */
+	static add(out: VEC3, v1: VEC3, v2: VEC3) {
+		out.x = v1.x + v2.x;
+		out.y = v1.y + v2.y;
+		out.z = v1.z + v2.z;
+	}
+
+	/** Subtraction of two 3-dimensional vectors. */
+	static sub(out: VEC3, v1: VEC3, v2: VEC3) {
+		out.x = v1.x - v2.x;
+		out.y = v1.y - v2.y;
+		out.z = v1.z - v2.z;
+	}
+
+	/** Multiplication of a 3-dimensional vector by a scalar. */
+	static scale(out: VEC3, v1: VEC3, x: number) {
+		out.x = v1.x * x;
+		out.y = v1.y * x;
+		out.z = v1.z * x;
+	}
 }