common.hpp

#pragma once

#include <string>
#include <algorithm>
//using namespace std;

#define PI 3.1415926535897932384626433832795028841971693993751058209749445923078164062f
#define PI2 PI*2.f; 

struct vec3;
typedef vec3 point3;
struct vec2;
typedef vec2 point2;
struct line;
struct plane;
struct intersection;
struct colRGB;
//Vectors
struct vec3
{
public:
	vec3();
	vec3(float x, float y, float z);

	float x;
	float y;
	float z;

	inline friend vec3	operator*(float factor, const vec3& rightRef){
		return vec3(rightRef.x * factor, rightRef.y * factor, rightRef.z*factor);
	}

	//methods
	inline float Dot(const vec3& otherRef) const{
		return x * otherRef.x + y * otherRef.y + z*otherRef.z;
	}
	inline float Length() const{
		return sqrt(pow(x, 2) + pow(y, 2) + pow(z, 2));
	}
	inline float Angle(const vec3& otherRef) const{
		return acos((vec3(x, y, z).Dot(otherRef)) / (vec3(x, y, z).Length() / otherRef.Length()));
	}
	inline vec3 Norm(float epsilon = 0.001) const{
		if (Length() < epsilon)return vec3(0, 0, 0);
		else return vec3(x, y, z) / Length();
	}
	inline vec3 Cross(const vec3& otherRef) const{
		return vec3(y * otherRef.z - z * otherRef.y, z * otherRef.x - x * otherRef.z, x * otherRef.y - y * otherRef.x);
	}
	inline std::string ToString() const{
		using namespace std;
		return string("x: ") + to_string(x) + string(", y: ") + to_string(y) + string(", z: ") + to_string(z);
	}

	//Operators	
	inline vec3&			operator= (const vec3& otherRef){
		if (&otherRef != this){
			x = otherRef.x;
			y = otherRef.y;
			z = otherRef.z;
		}
		return *this;
	}
	inline vec3			operator+ (const vec3& otherRef) const{
		return vec3(x + otherRef.x, y + otherRef.y, z + otherRef.z);
	}
	inline vec3			operator- (const vec3& otherRef) const{
		return vec3(x - otherRef.x, y - otherRef.y, z - otherRef.z);
	}
	inline vec3			operator- () const{
		return vec3(-x, -y, -z);
	}
	inline vec3			operator+ () const{
		return *this;
	}
	inline vec3			operator* (float factor) const{
		return vec3(x * factor, y * factor, z*factor);
	}
	inline vec3			operator/ (float divisor) const{
		return vec3(x / divisor, y / divisor, z / divisor);
	}
	inline vec3&			operator+=(const vec3& otherRef){
		x += otherRef.x;
		y += otherRef.y;
		z += otherRef.z;
		return *this;
	}
	inline vec3&			operator-=(const vec3& otherRef){
		x -= otherRef.x;
		y -= otherRef.y;
		z -= otherRef.z;
		return *this;
	}
	inline vec3&			operator*=(float factor){
		x *= factor;
		y *= factor;
		z *= factor;
		return *this;
	}
	inline vec3&			operator/=(float divisor){
		x /= divisor;
		y /= divisor;
		z /= divisor;
		return *this;
	}
	inline bool			operator==(const vec3& otherRef) const{
		return x == otherRef.x && y == otherRef.y && z == otherRef.z;
	}
	inline bool			operator!=(const vec3& otherRef) const{
		return !(*this == otherRef);
	}
};

struct vec2
{
public:
	vec2();
	vec2(float x, float y);

	float x;
	float y;

	inline friend vec2	operator*(float factor, const vec2& rightRef){
		return vec2(rightRef.x * factor, rightRef.y * factor);
	}

	//methods
	inline float Dot(const vec2& otherRef) const{
		return x * otherRef.x + y * otherRef.y;
	}
	inline float Length() const{
		return sqrt(pow(x, 2) + pow(y, 2));
	}
	inline float Angle(const vec2& otherRef) const{
		return acos((vec2(x, y).Dot(otherRef)) / (vec2(x, y).Length() / otherRef.Length()));
	}
	inline vec2 Norm(float epsilon = 0.001) const{
		if (Length() < epsilon)return vec2(0, 0);
		else return vec2(x, y) / Length();
	}
	inline vec2 Orthagonal() const{
		return vec2(-y, x);
	}
	inline std::string ToString() const{
		using namespace std;
		return string("x: ") + to_string(x) + string(", y: ") + to_string(y);
	}
	inline vec2 correctUV() const{
		vec2 ret = vec2(x, y);
		if (x > 1){
			int intX = (int)x;
			ret.x = x - intX;
		}
		if (x < 0){
			int intX = (int)x;
			ret.x = -(x - intX);
		}
		if (y > 1){
			int intY = (int)y;
			ret.y = y - intY;
		}
		if (y < 0){
			int intY = (int)y;
			ret.y = -(y - intY);
		}
		return ret;
	}

	//Operators	
	inline vec2&			operator= (const vec2& otherRef){
		if (&otherRef != this){
			x = otherRef.x;
			y = otherRef.y;
		}
		return *this;
	}
	inline vec2			operator+ (const vec2& otherRef) const{
		return vec2(x + otherRef.x, y + otherRef.y);
	}
	inline vec2			operator- (const vec2& otherRef) const{
		return vec2(x - otherRef.x, y - otherRef.y);
	}
	inline vec2			operator- () const{
		return vec2(-x, -y);
	}
	inline vec2			operator+ () const{
		return *this;
	}
	inline vec2			operator* (float factor) const{
		return vec2(x * factor, y * factor);
	}
	inline vec2			operator/ (float divisor) const{
		return vec2(x / divisor, y / divisor);
	}
	inline vec2&			operator+=(const vec2& otherRef){
		x += otherRef.x;
		y += otherRef.y;
		return *this;
	}
	inline vec2&			operator-=(const vec2& otherRef){
		x -= otherRef.x;
		y -= otherRef.y;
		return *this;
	}
	inline vec2&			operator*=(float factor){
		x *= factor;
		y *= factor;
		return *this;
	}
	inline vec2&			operator/=(float divisor){
		x /= divisor;
		y /= divisor;
		return *this;
	}
	inline bool			operator==(const vec2& otherRef) const{
		return x == otherRef.x && y == otherRef.y;
	}
	inline bool			operator!=(const vec2& otherRef) const{
		return !(*this == otherRef);
	}
};

struct line{
	line();
	line(point3, vec3);

	point3 orig;
	vec3 dir;
};

struct intersection{
	intersection();
	intersection(bool, point3, float);
	bool hit;
	point3 p;
	float t;
	bool backfacing = false;
};

struct plane{
	plane();
	plane(vec3, float);
	plane(point3, point3, point3);

	vec3 n;
	float d;

	inline intersection lineIts(line ln){
		intersection ret(false, point3(0, 0, 0), 0);
		float nd = n.Dot(ln.dir);
		if (!(nd == 0)){
			ret.t = (d - n.Dot(ln.orig)) / nd;
			ret.hit = true;
		}
		return ret;
	}
	inline intersection rayIts(line ln, bool bfc){
		intersection ret(false, point3(0, 0, 0), 0);
		float nd = n.Dot(ln.dir);
		if (nd<0){
			ret.t = (d - n.Dot(ln.orig)) / nd;
			ret.hit = true;
			ret.backfacing = false;
		}
		else if (nd>0 && bfc == false){
			ret.t = (d - n.Dot(ln.orig)) / nd;
			ret.hit = true;
			ret.backfacing = true;
		}
		return ret;
	}
};

struct colRGB
{
public:
	colRGB();
	colRGB(float red, float green, float blue);

	float red;
	float green;
	float blue;

	inline std::string			ToString() const{
		using namespace std;
		return string("red: ") + to_string(red) + string(", green: ") + to_string(green) + string(", blue: ") + to_string(blue);
	}

	inline friend colRGB operator*(float factor, const colRGB& rightRef){
		return colRGB(rightRef.red * factor, rightRef.green * factor, rightRef.blue*factor);
	}

	inline colRGB&		operator= (const colRGB& otherRef){
		if (&otherRef != this){
			red = otherRef.red;
			green = otherRef.green;
			blue = otherRef.blue;
		}
		return *this;
	}
	inline colRGB		operator+ (const colRGB& otherRef) const{
		return colRGB(red + otherRef.red, green + otherRef.green, blue + otherRef.blue);
	}
	inline colRGB		operator- (const colRGB& otherRef) const{
		return colRGB(red - otherRef.red, green - otherRef.green, blue - otherRef.blue);
	}
	inline colRGB		operator- () const{
		return colRGB(-red, -green, -blue);
	}
	inline colRGB		operator+ () const{
		return *this;
	}
	inline colRGB		operator* (float factor) const{
		return colRGB(red * factor, green * factor, blue*factor);
	}
	inline colRGB		operator* (const colRGB& otherRef) const{
		return colRGB(((red)*(otherRef.red)),
			((green)*(otherRef.green)),
			((blue)*(otherRef.blue)));
	}
	inline colRGB		operator/ (float divisor) const{
		return colRGB(red / divisor, green / divisor, blue / divisor);
	}
	inline colRGB&		operator+=(const colRGB& otherRef){
		red += otherRef.red;
		green += otherRef.green;
		blue += otherRef.blue;
		return *this;
	}
	inline colRGB&		operator-=(const colRGB& otherRef){
		red -= otherRef.red;
		green -= otherRef.green;
		blue -= otherRef.blue;
		return *this;
	}
	inline colRGB&		operator*=(float factor){
		red *= factor;
		green *= factor;
		blue *= factor;
		return *this;
	}
	inline colRGB&		operator*=(const colRGB& otherRef){
		red = ((red)*(otherRef.red));
		green = ((green)*(otherRef.green));
		blue = ((blue)*(otherRef.blue));
		return *this;
	}
	inline colRGB&		operator/=(float divisor){
		red /= divisor;
		green /= divisor;
		blue /= divisor;
		return *this;
	}
	inline bool		operator==(const colRGB& otherRef) const{
		return red == otherRef.red && green == otherRef.green && blue == otherRef.blue;
	}
	inline bool		operator!=(const colRGB& otherRef) const{
		return !(*this == otherRef);
	}
};

namespace LW_Util{
	using namespace std;
	inline std::string getTimeFromFloat(float time)
	{
		int seconds = (int)time;
		int minutes = (int)(time / 60.f);
		seconds -= minutes * 60;
		int hours = (int)(time / 3600.f);
		minutes -= hours * 60;
		string hoursString = hours > 9 ? to_string(hours) : '0' + to_string(hours);
		string minutesString = minutes > 9 ? to_string(minutes) : '0' + to_string(minutes);
		string secondsString = seconds > 9 ? to_string(seconds) : '0' + to_string(seconds);
		if (hours > 0)
		{
			return hoursString + ":" + minutesString + ":" + secondsString;
		}
		else return minutesString + ":" + secondsString;
	}
}