isle/LEGO1/realtime/mxvector.h

#ifndef MXVECTOR_H
#define MXVECTOR_H

#include "../mxtypes.h"

#include <vec.h>

/*
 * A simple array of three floats that can be indexed into.
 */
class Vector3 {
public:
	float elements[3]; // storage is public for easy access
	Vector3() {}
	Vector3(float x, float y, float z)
	{
		elements[0] = x;
		elements[1] = y;
		elements[2] = z;
	}
	Vector3(const float v[3])
	{
		elements[0] = v[0];
		elements[1] = v[1];
		elements[2] = v[2];
	}
	const float& operator[](long i) const { return elements[i]; }
	float& operator[](long i) { return elements[i]; }
};

/*
 * A simple array of four floats that can be indexed into.
 */
struct Vector4 {
public:
	float elements[4]; // storage is public for easy access
	inline Vector4() {}
	Vector4(float x, float y, float z, float w)
	{
		elements[0] = x;
		elements[1] = y;
		elements[2] = z;
		elements[3] = w;
	}
	Vector4(const float v[4])
	{
		elements[0] = v[0];
		elements[1] = v[1];
		elements[2] = v[2];
		elements[3] = v[3];
	}
	const float& operator[](long i) const { return elements[i]; }
	float& operator[](long i) { return elements[i]; }
};

// VTABLE 0x100d4288
// SIZE 0x8
class MxVector2 {
public:
	// OFFSET: LEGO1 0x1000c0f0
	inline MxVector2(float* p_data) { this->SetData(p_data); }

	// vtable + 0x00 (no virtual destructor)
	virtual void AddScalarImpl(float p_value) = 0;
	virtual void AddVectorImpl(float* p_value) = 0;
	virtual void SubVectorImpl(float* p_value) = 0;
	virtual void MullScalarImpl(float* p_value) = 0;

	// vtable + 0x10
	virtual void MullVectorImpl(float* p_value) = 0;
	virtual void DivScalarImpl(float* p_value) = 0;
	virtual float DotImpl(float* p_a, float* p_b) const = 0;

	// OFFSET: LEGO1 0x10002060
	virtual void SetData(float* p_data) { this->m_data = p_data; }

	// vtable + 0x20
	virtual void EqualsImpl(float* p_data) = 0;
	virtual float* GetData();
	virtual const float* GetData() const;
	virtual void Clear() = 0;

	// vtable + 0x30
	virtual float Dot(MxVector2* p_a, float* p_b) const;
	virtual float Dot(float* p_a, MxVector2* p_b) const;
	virtual float Dot(MxVector2* p_a, MxVector2* p_b) const;
	virtual float Dot(float* p_a, float* p_b) const;

	// vtable + 0x40
	virtual float LenSquared() const = 0;
	virtual MxResult Unitize();

	// vtable + 0x48
	virtual void AddVector(MxVector2* p_other);
	virtual void AddVector(float* p_other);
	virtual void AddScalar(float p_value);

	// vtable + 0x54
	virtual void SubVector(MxVector2* p_other);
	virtual void SubVector(float* p_other);

	// vtable + 0x5C
	virtual void MullScalar(float* p_value);
	virtual void MullVector(MxVector2* p_other);
	virtual void MullVector(float* p_other);
	virtual void DivScalar(float* p_value);

	// vtable + 0x6C
	virtual void SetVector(MxVector2* p_other);
	virtual void SetVector(float* p_other);

	inline float& operator[](size_t idx) { return m_data[idx]; }
	inline const float& operator[](size_t idx) const { return m_data[idx]; }

protected:
	float* m_data;
};

// VTABLE 0x100d4518
// SIZE 0x8
class MxVector3 : public MxVector2 {
public:
	inline MxVector3(float* p_data) : MxVector2(p_data) {}

	void AddScalarImpl(float p_value);

	void AddVectorImpl(float* p_value);

	void SubVectorImpl(float* p_value);
	void MullScalarImpl(float* p_value);
	void MullVectorImpl(float* p_value);
	void DivScalarImpl(float* p_value);
	float DotImpl(float* p_a, float* p_b) const;

	void EqualsImpl(float* p_data);

	void Clear();

	float LenSquared() const;

	// vtable + 0x74
	virtual void EqualsCrossImpl(float* p_a, float* p_b);
	virtual void EqualsCross(float* p_a, MxVector3* p_b);
	virtual void EqualsCross(MxVector3* p_a, float* p_b);
	virtual void EqualsCross(MxVector3* p_a, MxVector3* p_b);
	virtual void EqualsScalar(float* p_value);

	inline void Fill(float p_value) { EqualsScalar(&p_value); }
};

// VTABLE 0x100d45a0
// SIZE 0x8
class MxVector4 : public MxVector3 {
public:
	inline MxVector4(float* p_data) : MxVector3(p_data) {}

	void AddScalarImpl(float p_value);

	void AddVectorImpl(float* p_value);

	void SubVectorImpl(float* p_value);
	void MullScalarImpl(float* p_value);
	void MullVectorImpl(float* p_value);
	void DivScalarImpl(float* p_value);
	float DotImpl(float* p_a, float* p_b) const;

	void EqualsImpl(float* p_data);

	void Clear();

	float LenSquared() const;

	void EqualsScalar(float* p_value);

	// vtable + 0x84
	virtual void SetMatrixProduct(MxVector4* p_a, float* p_b);
	virtual void SetMatrixProductImpl(float* p_vec, float* p_mat);
	virtual MxResult NormalizeQuaternion();
	virtual void UnknownQuaternionOp(MxVector4* p_a, MxVector4* p_b);
};

// VTABLE 0x100d4488
// SIZE 0x14
class MxVector3Data : public MxVector3 {
public:
	inline MxVector3Data() : MxVector3(storage) {}
	inline MxVector3Data(float p_x, float p_y, float p_z) : MxVector3(storage), x(p_x), y(p_y), z(p_z) {}

	union {
		float storage[3];
		struct {
			float x;
			float y;
			float z;
		};
	};

	void CopyFrom(MxVector3Data& p_other)
	{
		EqualsImpl(p_other.m_data);

		float* dest = this->storage;
		float* src = p_other.storage;
		for (size_t i = sizeof(storage) / sizeof(float); i > 0; --i)
			*dest++ = *src++;
	}
};

// VTABLE 0x100d41e8
// SIZE 0x18
class MxVector4Data : public MxVector4 {
public:
	inline MxVector4Data() : MxVector4(storage) {}
	union {
		float storage[4];
		struct {
			float x;
			float y;
			float z;
			float w;
		};
	};
};

#endif // MXVECTOR_H