worldspawn/libs/generic/vector.h

#if !defined( INCLUDED_VECTOR_H )
#define INCLUDED_VECTOR_H

#include <cstddef>

template <typename Element>
class BasicVector2
{
Element m_elements[2];
public:
BasicVector2(){
}
BasicVector2( const Element& x_, const Element& y_ ){
	x() = x_;
	y() = y_;
}

Element& x(){
	return m_elements[0];
}
const Element& x() const {
	return m_elements[0];
}
Element& y(){
	return m_elements[1];
}
const Element& y() const {
	return m_elements[1];
}

const Element& operator[]( std::size_t i ) const {
	return m_elements[i];
}
Element& operator[]( std::size_t i ){
	return m_elements[i];
}

Element* data(){
	return m_elements;
}
const Element* data() const {
	return m_elements;
}
};

/// \brief A 3-element vector.
template<typename Element>
class BasicVector3
{
Element m_elements[3];
public:

BasicVector3(){
}
template<typename OtherElement>
BasicVector3( const BasicVector3<OtherElement>& other ){
	x() = static_cast<Element>( other.x() );
	y() = static_cast<Element>( other.y() );
	z() = static_cast<Element>( other.z() );
}
BasicVector3( const Element& x_, const Element& y_, const Element& z_ ){
	x() = x_;
	y() = y_;
	z() = z_;
}

Element& x(){
	return m_elements[0];
}
const Element& x() const {
	return m_elements[0];
}
Element& y(){
	return m_elements[1];
}
const Element& y() const {
	return m_elements[1];
}
Element& z(){
	return m_elements[2];
}
const Element& z() const {
	return m_elements[2];
}

const Element& operator[]( std::size_t i ) const {
	return m_elements[i];
}
Element& operator[]( std::size_t i ){
	return m_elements[i];
}

Element* data(){
	return m_elements;
}
const Element* data() const {
	return m_elements;
}
};

/// \brief A 4-element vector.
template<typename Element>
class BasicVector4
{
Element m_elements[4];
public:

BasicVector4(){
}
BasicVector4( Element x_, Element y_, Element z_, Element w_ ){
	x() = x_;
	y() = y_;
	z() = z_;
	w() = w_;
}
BasicVector4( const BasicVector3<Element>& self, Element w_ ){
	x() = self.x();
	y() = self.y();
	z() = self.z();
	w() = w_;
}

Element& x(){
	return m_elements[0];
}
const Element& x() const {
	return m_elements[0];
}
Element& y(){
	return m_elements[1];
}
const Element& y() const {
	return m_elements[1];
}
Element& z(){
	return m_elements[2];
}
const Element& z() const {
	return m_elements[2];
}
Element& w(){
	return m_elements[3];
}
const Element& w() const {
	return m_elements[3];
}

Element index( std::size_t i ) const {
	return m_elements[i];
}
Element& index( std::size_t i ){
	return m_elements[i];
}
Element operator[]( std::size_t i ) const {
	return m_elements[i];
}
Element& operator[]( std::size_t i ){
	return m_elements[i];
}

Element* data(){
	return m_elements;
}
const Element* data() const {
	return m_elements;
}
};

template<typename Element>
inline BasicVector3<Element> vector3_from_array( const Element* array ){
	return BasicVector3<Element>( array[0], array[1], array[2] );
}

template<typename Element>
inline Element* vector3_to_array( BasicVector3<Element>& self ){
	return self.data();
}
template<typename Element>
inline const Element* vector3_to_array( const BasicVector3<Element>& self ){
	return self.data();
}

template<typename Element>
inline Element* vector4_to_array( BasicVector4<Element>& self ){
	return self.data();
}
template<typename Element>
inline const Element* vector4_to_array( const BasicVector4<Element>& self ){
	return self.data();
}

template<typename Element>
inline BasicVector3<Element>& vector4_to_vector3( BasicVector4<Element>& self ){
	return *reinterpret_cast<BasicVector3<Element>*>( vector4_to_array( self ) );
}
template<typename Element>
inline const BasicVector3<Element>& vector4_to_vector3( const BasicVector4<Element>& self ){
	return *reinterpret_cast<const BasicVector3<Element>*>( vector4_to_array( self ) );
}

/// \brief A 2-element vector stored in single-precision floating-point.
typedef BasicVector2<float> Vector2;

/// \brief A 3-element vector stored in single-precision floating-point.
typedef BasicVector3<float> Vector3;

/// \brief A 4-element vector stored in single-precision floating-point.
typedef BasicVector4<float> Vector4;


#endif