Initial commit

engines/hpl1/engine/math/Vector3.h

@@ -0,0 +1,334 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+/*
+ * Copyright (C) 2006-2010 - Frictional Games
+ *
+ * This file is part of HPL1 Engine.
+ */
+
+#ifndef HPL_VECTOR3_H
+#define HPL_VECTOR3_H
+
+#include "hpl1/engine/math/Vector2.h"
+
+#define VEC3_CONST_ARRAY(name, vec) const float name[] = {vec.x, vec.y, vec.z}
+
+namespace hpl {
+
+template<class T>
+class cVector3 {
+public:
+	T x, y, z;
+
+	constexpr cVector3() : x(0), y(0), z(0) {
+	}
+	constexpr cVector3(T aVal) : x(aVal), y(aVal), z(aVal) {
+	}
+	constexpr cVector3(T aX, T aY, T aZ) : x(aX), y(aY), z(aZ) {
+	}
+
+	constexpr cVector3(cVector3<T> const &aVec) : x(aVec.x), y(aVec.y), z(aVec.z) {
+	}
+
+	constexpr cVector3(cVector2<T> const &aVec) : x(aVec.x), y(aVec.y), z(0) {
+	}
+
+	static cVector3 fromArray(const float vec[3]) {
+		return cVector3<T>(vec[0], vec[1], vec[2]);
+	}
+
+	//////////////////////////////////////////
+	// Copy
+	/////////////////////////////////////////
+
+	inline cVector3<T> &operator=(const cVector3<T> &aVec) {
+		x = aVec.x;
+		y = aVec.y;
+		z = aVec.z;
+		return *this;
+	}
+
+	inline cVector3<T> &operator=(const cVector2<T> &aVec) {
+		x = aVec.x;
+		y = aVec.y;
+		return *this;
+	}
+
+	inline cVector3<T> &operator=(const T aVal) {
+		x = aVal;
+		y = aVal;
+		z = aVal;
+		return *this;
+	}
+
+	//////////////////////////////////////////
+	// Boolean
+	/////////////////////////////////////////
+
+	inline bool operator==(const cVector3<T> &aVec) const {
+		if (x == aVec.x && y == aVec.y && z == aVec.z)
+			return true;
+		else
+			return false;
+	}
+
+	inline bool operator!=(const cVector3<T> &aVec) const {
+		if (x == aVec.x && y == aVec.y && z == aVec.z)
+			return false;
+		else
+			return true;
+	}
+
+	inline bool operator<(const cVector3<T> &aVec) const {
+		if (x != aVec.x)
+			return x < aVec.x;
+		if (y != aVec.y)
+			return y < aVec.y;
+		return z < aVec.z;
+	}
+
+	inline bool operator>(const cVector3<T> &aVec) const {
+		if (x != aVec.x)
+			return x > aVec.x;
+		if (y != aVec.y)
+			return y > aVec.y;
+		return z > aVec.z;
+	}
+
+	//////////////////////////////////////////
+	// Vector3 Arithmetic
+	/////////////////////////////////////////
+
+	inline cVector3<T> operator+(const cVector3<T> &aVec) const {
+		cVector3<T> vec;
+		vec.x = x + aVec.x;
+		vec.y = y + aVec.y;
+		vec.z = z + aVec.z;
+		return vec;
+	}
+
+	inline cVector3<T> operator-(const cVector3<T> &aVec) const {
+		cVector3<T> vec;
+		vec.x = x - aVec.x;
+		vec.y = y - aVec.y;
+		vec.z = z - aVec.z;
+		return vec;
+	}
+
+	inline cVector3<T> operator*(const cVector3<T> &aVec) const {
+		cVector3<T> vec;
+		vec.x = x * aVec.x;
+		vec.y = y * aVec.y;
+		vec.z = z * aVec.z;
+		return vec;
+	}
+
+	inline cVector3<T> operator/(const cVector3<T> &aVec) const {
+		cVector3<T> vec;
+		vec.x = x / aVec.x;
+		vec.y = y / aVec.y;
+		vec.z = z / aVec.z;
+		return vec;
+	}
+
+	inline cVector3<T> &operator-=(const cVector3<T> &aVec) {
+		x -= aVec.x;
+		y -= aVec.y;
+		z -= aVec.z;
+		return *this;
+	}
+
+	inline cVector3<T> &operator+=(const cVector3<T> &aVec) {
+		x += aVec.x;
+		y += aVec.y;
+		z += aVec.z;
+		return *this;
+	}
+
+	inline cVector3<T> &operator*=(const cVector3<T> &aVec) {
+		x *= aVec.x;
+		y *= aVec.y;
+		z *= aVec.z;
+		return *this;
+	}
+
+	inline cVector3<T> &operator/=(const cVector3<T> &aVec) {
+		x /= aVec.x;
+		y /= aVec.y;
+		z /= aVec.z;
+		return *this;
+	}
+
+	//////////////////////////////////////////
+	// Vector2 Arithmetic
+	/////////////////////////////////////////
+
+	inline cVector3<T> operator+(const cVector2<T> &aVec) const {
+		cVector3<T> vec;
+		vec.x = x + aVec.x;
+		vec.y = y + aVec.y;
+		vec.z = z;
+		return vec;
+	}
+
+	inline cVector3<T> operator-(const cVector2<T> &aVec) const {
+		cVector3<T> vec;
+		vec.x = x - aVec.x;
+		vec.y = y - aVec.y;
+		vec.z = z;
+		return vec;
+	}
+
+	inline cVector3<T> operator*(const cVector2<T> &aVec) const {
+		cVector3<T> vec;
+		vec.x = x * aVec.x;
+		vec.y = y * aVec.y;
+		vec.z = z;
+		return vec;
+	}
+
+	inline cVector3<T> operator/(const cVector2<T> &aVec) const {
+		cVector3<T> vec;
+		vec.x = x / aVec.x;
+		vec.y = y / aVec.y;
+		vec.z = z;
+		return vec;
+	}
+
+	inline cVector3<T> &operator-=(const cVector2<T> &aVec) {
+		x -= aVec.x;
+		y -= aVec.y;
+		return *this;
+	}
+
+	inline cVector3<T> &operator+=(const cVector2<T> &aVec) {
+		x += aVec.x;
+		y += aVec.y;
+		return *this;
+	}
+
+	inline cVector3<T> &operator*=(const cVector2<T> &aVec) {
+		x *= aVec.x;
+		y *= aVec.y;
+		return *this;
+	}
+
+	inline cVector3<T> &operator/=(const cVector2<T> &aVec) {
+		x /= aVec.x;
+		y /= aVec.y;
+		return *this;
+	}
+
+	//////////////////////////////////////////
+	// Single Float Arithmetic
+	/////////////////////////////////////////
+
+	inline cVector3<T> operator/(const T &aVal) const {
+		cVector3<T> vec;
+		vec.x = x / aVal;
+		vec.y = y / aVal;
+		vec.z = z / aVal;
+		return vec;
+	}
+
+	inline cVector3<T> operator*(const T &aVal) const {
+		cVector3<T> vec;
+		vec.x = x * aVal;
+		vec.y = y * aVal;
+		vec.z = z * aVal;
+		return vec;
+	}
+
+	inline cVector3<T> operator+(const T &aVal) const {
+		cVector3<T> vec;
+		vec.x = x + aVal;
+		vec.y = y + aVal;
+		vec.z = z + aVal;
+		return vec;
+	}
+
+	cVector3<T> operator-(const T &aVal) const {
+		cVector3<T> vec;
+		vec.x = x - aVal;
+		vec.y = y - aVal;
+		vec.z = z - aVal;
+		return vec;
+	}
+
+	//////////////////////////////////////////
+	// Methods
+	/////////////////////////////////////////
+
+	inline void FromVec(const T *apVec) {
+		x = apVec[0];
+		y = apVec[1];
+		z = apVec[2];
+	}
+
+	inline T Length() {
+		return sqrt(x * x + y * y + z * z);
+	}
+
+	inline T SqrLength() {
+		return x * x + y * y + z * z;
+	}
+
+	/**
+	 * Only use this on double or float vectors
+	 * \return Length of Vector
+	 */
+	T Normalise() {
+		T length = sqrt(x * x + y * y + z * z);
+
+		// Will also work for zero-sized vectors, but will change nothing
+		if (length > 1e-08) {
+			T InvLength = 1.0f / length;
+			x *= InvLength;
+			y *= InvLength;
+			z *= InvLength;
+		}
+
+		return length;
+	}
+
+	//////////////////////////////////////////
+	// Printing
+	/////////////////////////////////////////
+
+	tString ToString() const {
+		char buf[512];
+		snprintf(buf, 512, "%f : %f : %f", x, y, z);
+		tString str = buf;
+		return str;
+	}
+
+	tString ToFileString() const {
+		char buf[512];
+		snprintf(buf, 512, "%g %g %g", x, y, z);
+		tString str = buf;
+		return str;
+	}
+};
+
+} // namespace hpl
+
+#endif // HPL_VECTOR3_H