oops, readd crunch submodule

[xonotic/netradiant.git] / libs / generic / vector.h

diff --git a/libs/generic/vector.h b/libs/generic/vector.h
index 6e6f74e2a5a1cb47fc32f4a43fa21a0449959239..ea1e3bdb7507ab35847f659436a5c410f1fed330 100644 (file)
--- a/libs/generic/vector.h
+++ b/libs/generic/vector.h
@@ -1,5 +1,5 @@
 
-#if !defined(INCLUDED_VECTOR_H)
+#if !defined( INCLUDED_VECTOR_H )
 #define INCLUDED_VECTOR_H
 
 #include <cstddef>
@@ -7,243 +7,196 @@
 template <typename Element>
 class BasicVector2
 {
-  Element m_elements[2];
+Element m_elements[2];
 public:
-  BasicVector2()
-  {
-  }
-  BasicVector2(const Element& x_, const Element& y_)
-  {
-    x() = x_;
-    y() = y_;
-  }
+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];
-  }
+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];
-  }
+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;
-  }
+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];
+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_;
-  }
+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];
-  }
+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];
-  }
+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;
-  }
+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];
+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_;
-  }
+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& 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 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;
-  }
+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]);
+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();
+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();
+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();
+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();
+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));
+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));
+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.