0ad/source/maths/Vector4D.h

/* Copyright (C) 2022 Wildfire Games.
 * This file is part of 0 A.D.
 *
 * 0 A.D. 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 2 of the License, or
 * (at your option) any later version.
 *
 * 0 A.D. 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 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
 */

/*
 * Provides an interface for a vector in R4 and allows vector and
 * scalar operations on it
 */

#ifndef INCLUDED_VECTOR4D
#define INCLUDED_VECTOR4D

#include "ps/containers/Span.h"

#include <math.h>

class CVector4D
{
public:
	CVector4D() : X(0.0f), Y(0.0f), Z(0.0f), W(0.0f) { }

	CVector4D(float x, float y, float z, float w) : X(x), Y(y), Z(z), W(w) { }

	bool operator==(const CVector4D& t) const
	{
		return (X == t.X && Y == t.Y && Z == t.Z && W == t.W);
	}

	bool operator!=(const CVector4D& t) const
	{
		return !(*this == t);
	}

	CVector4D operator-() const
	{
		return CVector4D(-X, -Y, -Z, -W);
	}

	CVector4D operator+(const CVector4D& t) const
	{
		return CVector4D(X+t.X, Y+t.Y, Z+t.Z, W+t.W);
	}

	CVector4D operator-(const CVector4D& t) const
	{
		return CVector4D(X-t.X, Y-t.Y, Z-t.Z, W-t.W);
	}

	CVector4D operator*(const CVector4D& t) const
	{
		return CVector4D(X*t.X, Y*t.Y, Z*t.Z, W*t.W);
	}

	CVector4D operator*(float f) const
	{
		return CVector4D(X*f, Y*f, Z*f, W*f);
	}

	CVector4D operator/(float f) const
	{
		float inv_f = 1.0f / f;
		return CVector4D(X*inv_f, Y*inv_f, Z*inv_f, W*inv_f);
	}

	CVector4D& operator+=(const CVector4D& t)
	{
		X += t.X;
		Y += t.Y;
		Z += t.Z;
		W += t.W;
		return *this;
	}

	CVector4D& operator-=(const CVector4D& t)
	{
		X -= t.X;
		Y -= t.Y;
		Z -= t.Z;
		W -= t.W;
		return *this;
	}

	CVector4D& operator*=(const CVector4D& t)
	{
		X *= t.X;
		Y *= t.Y;
		Z *= t.Z;
		W *= t.W;
		return *this;
	}

	CVector4D& operator*=(float f)
	{
		X *= f;
		Y *= f;
		Z *= f;
		W *= f;
		return *this;
	}

	CVector4D& operator/=(float f)
	{
		float inv_f = 1.0f / f;
		X *= inv_f;
		Y *= inv_f;
		Z *= inv_f;
		W *= inv_f;
		return *this;
	}

	float Dot(const CVector4D& a) const
	{
		return X*a.X + Y*a.Y + Z*a.Z + W*a.W;
	}

	// Returns 4 element array of floats, e.g. for vec4 uniforms.
	PS::span<const float> AsFloatArray() const
	{
		// Additional check to prevent a weird compiler has a different
		// alignement for an array and a class members.
		static_assert(
			sizeof(CVector4D) == sizeof(float) * 4u &&
			offsetof(CVector4D, X) == 0 &&
			offsetof(CVector4D, W) == sizeof(float) * 3u,
			"CVector4D should be properly layouted to use AsFloatArray");
		return PS::span<const float>(&X, 4);
	}

	float X, Y, Z, W;
};

#endif // INCLUDED_VECTOR4D