PolyVoxCore/include/PolyVoxCore/Vector.inl

Go to the documentation of this file.

/*******************************************************************************
Copyright (c) 2005-2009 David Williams

This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any damages
arising from the use of this software.

Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it
freely, subject to the following restrictions:

    1. The origin of this software must not be misrepresented; you must not
    claim that you wrote the original software. If you use this software
    in a product, an acknowledgment in the product documentation would be
    appreciated but is not required.

    2. Altered source versions must be plainly marked as such, and must not be
    misrepresented as being the original software.

    3. This notice may not be removed or altered from any source
    distribution.   
*******************************************************************************/

namespace PolyVox
{
    //-------------------------- Constructors, etc ---------------------------------
    template <uint32_t Size,typename Type>
        Vector<Size,Type>::Vector(Type x, Type y) throw()
    {
        m_tElements[0] = x;
        m_tElements[1] = y;

    }

    template <uint32_t Size,typename Type>
        Vector<Size,Type>::Vector(Type x, Type y, Type z) throw()
    {
        m_tElements[0] = x;
        m_tElements[1] = y;
        m_tElements[2] = z;

    }

    template <uint32_t Size,typename Type>
        Vector<Size,Type>::Vector(Type x, Type y, Type z, Type w) throw()
    {
        m_tElements[0] = x;
        m_tElements[1] = y;
        m_tElements[2] = z;
        m_tElements[3] = w;
    }

    template <uint32_t Size, typename Type>
        Vector<Size, Type>::Vector(void) throw()
    {
    }

    template <uint32_t Size, typename Type>
        Vector<Size, Type>::Vector(const Vector<Size, Type>& vector) throw()
    {
        std::memcpy(m_tElements, vector.m_tElements, sizeof(Type) * Size);
    }

    template <uint32_t Size, typename Type>
        template <typename CastType>
        Vector<Size, Type>::Vector(const Vector<Size, CastType>& vector) throw()
    {
        for(uint32_t ct = 0; ct < Size; ++ct)
        {
            m_tElements[ct] = static_cast<Type>(vector.getElement(ct));
        }
    }

    template <uint32_t Size, typename Type>
        Vector<Size, Type>::~Vector(void) throw()
    {
    }

    template <uint32_t Size, typename Type>
        Vector<Size, Type>& Vector<Size, Type>::operator=(const Vector<Size, Type>& rhs) throw()
    {
        if(this == &rhs)
        {
            return *this;
        }
        std::memcpy(m_tElements, rhs.m_tElements, sizeof(Type) * Size);
        return *this;
    }

    template <uint32_t Size, typename Type>
        inline bool Vector<Size, Type>::operator==(const Vector<Size, Type> &rhs) const throw()
    {
        bool equal = true;
        for(uint32_t ct = 0; ct < Size; ++ct)
        {
            if(m_tElements[ct] != rhs.m_tElements[ct])
            {
                equal = false;
                break;
            }
        }
        return equal;
    }

    template <uint32_t Size, typename Type>
        inline bool Vector<Size, Type>::operator!=(const Vector<Size, Type> &rhs) const throw()
    {
        return !(*this == rhs); //Just call equality operator and invert the result.
    }

    template <uint32_t Size, typename Type>
        inline bool Vector<Size, Type>::operator<(const Vector<Size, Type> &rhs) const throw()
    {
        for(uint32_t ct = 0; ct < Size; ++ct)
        {
            if (m_tElements[ct] < rhs.m_tElements[ct])
                return true;
            if (rhs.m_tElements[ct] < m_tElements[ct])
                return false;
        }
        return false;
    }    

    template <uint32_t Size, typename Type>
        inline Vector<Size, Type>& Vector<Size, Type>::operator+=(const Vector<Size, Type>& rhs) throw()
    {
        for(uint32_t ct = 0; ct < Size; ++ct)
        {
            m_tElements[ct] += rhs.m_tElements[ct];
        }
        return *this;
    }

    template <uint32_t Size, typename Type>
        inline Vector<Size, Type>& Vector<Size, Type>::operator-=(const Vector<Size, Type>& rhs) throw()
    {
        for(uint32_t ct = 0; ct < Size; ++ct)
        {
            m_tElements[ct] -= rhs.m_tElements[ct];
        }
        return *this;
    }

    template <uint32_t Size, typename Type>
        inline Vector<Size, Type>& Vector<Size, Type>::operator*=(const Vector<Size, Type>& rhs) throw()
    {
        for(uint32_t ct = 0; ct < Size; ++ct)
        {
            m_tElements[ct] *= rhs.m_tElements[ct];
        }
        return *this;
    }

    template <uint32_t Size, typename Type>
        inline Vector<Size, Type>& Vector<Size, Type>::operator/=(const Vector<Size, Type>& rhs) throw()
    {
        for(uint32_t ct = 0; ct < Size; ++ct)
        {
            m_tElements[ct] /= rhs.m_tElements[ct];
        }
        return *this;
    }

    template <uint32_t Size, typename Type>
        inline Vector<Size, Type>& Vector<Size, Type>::operator*=(const Type& rhs) throw()
    {
        for(uint32_t ct = 0; ct < Size; ++ct)
        {
            m_tElements[ct] *= rhs;
        }
        return *this;
    }

    template <uint32_t Size, typename Type>
        inline Vector<Size, Type>& Vector<Size, Type>::operator/=(const Type& rhs) throw()
    {
        for(uint32_t ct = 0; ct < Size; ++ct)
        {
            m_tElements[ct] /= rhs;
        }
        return *this;
    }

    template <uint32_t Size,typename Type>
        Vector<Size,Type> operator+(const Vector<Size,Type>& lhs, const Vector<Size,Type>& rhs) throw()
    {
        Vector<Size,Type> result = lhs;
        result += rhs;
        return result;
    }

    template <uint32_t Size,typename Type>
        Vector<Size,Type> operator-(const Vector<Size,Type>& lhs, const Vector<Size,Type>& rhs) throw()
    {
        Vector<Size,Type> result = lhs;
        result -= rhs;
        return result;
    }

    template <uint32_t Size,typename Type>
        Vector<Size,Type> operator*(const Vector<Size,Type>& lhs, const Vector<Size,Type>& rhs) throw()
    {
        Vector<Size,Type> result = lhs;
        result *= rhs;
        return result;
    }

    template <uint32_t Size,typename Type>
        Vector<Size,Type> operator/(const Vector<Size,Type>& lhs, const Vector<Size,Type>& rhs) throw()
    {
        Vector<Size,Type> result = lhs;
        result /= rhs;
        return result;
    }

    template <uint32_t Size,typename Type>
        Vector<Size,Type> operator*(const Vector<Size,Type>& lhs, const Type& rhs) throw()
    {
        Vector<Size,Type> result = lhs;
        result *= rhs;
        return result;
    }

    template <uint32_t Size,typename Type>
        Vector<Size,Type> operator/(const Vector<Size,Type>& lhs, const Type& rhs) throw()
    {
        Vector<Size,Type> result = lhs;
        result /= rhs;
        return result;
    }

    template <uint32_t Size, typename Type>
        std::ostream& operator<<(std::ostream& os, const Vector<Size, Type>& vector) throw()
    {
        os << "(";
        for(uint32_t ct = 0; ct < Size; ++ct)
        {
            os << vector.getElement(ct);
            if(ct < (Size-1))
            {
                os << ",";
            }
        }
        os << ")";
        return os;
    }       

    template <uint32_t Size, typename Type>
        inline Type Vector<Size, Type>::getElement(uint32_t index) const throw()
    {
        return m_tElements[index];
    }

    template <uint32_t Size, typename Type>
        inline Type Vector<Size, Type>::getX(void) const throw()
    {
        return m_tElements[0];
    }   

    template <uint32_t Size, typename Type>
        inline Type Vector<Size, Type>::getY(void) const throw()
    {
        return m_tElements[1];
    }   

    template <uint32_t Size, typename Type>
        inline Type Vector<Size, Type>::getZ(void) const throw()
    {
        return m_tElements[2];
    }   

    template <uint32_t Size, typename Type>
        inline Type Vector<Size, Type>::getW(void) const throw()
    {
        return m_tElements[3];
    }  

    template <uint32_t Size, typename Type>
        inline void Vector<Size, Type>::setElement(uint32_t index, Type tValue) throw()
    {
        m_tElements[index] = tValue;
    }

    template <uint32_t Size,typename Type>
        inline void Vector<Size,Type>::setElements(Type x, Type y) throw()
    {
        m_tElements[0] = x;
        m_tElements[1] = y;

    }

    template <uint32_t Size,typename Type>
        inline void Vector<Size,Type>::setElements(Type x, Type y, Type z) throw()
    {
        m_tElements[0] = x;
        m_tElements[1] = y;
        m_tElements[2] = z;

    }

    template <uint32_t Size,typename Type>
        inline void Vector<Size,Type>::setElements(Type x, Type y, Type z, Type w) throw()
    {
        m_tElements[0] = x;
        m_tElements[1] = y;
        m_tElements[2] = z;
        m_tElements[3] = w;
    }

    template <uint32_t Size, typename Type>
        inline void Vector<Size, Type>::setX(Type tX) throw()
    {
        m_tElements[0] = tX;
    }

    template <uint32_t Size, typename Type>
        inline void Vector<Size, Type>::setY(Type tY) throw()
    {
        m_tElements[1] = tY;
    }

    template <uint32_t Size, typename Type>
        inline void Vector<Size, Type>::setZ(Type tZ) throw()
    {
        m_tElements[2] = tZ;
    }

    template <uint32_t Size, typename Type>
        inline void Vector<Size, Type>::setW(Type tW) throw()
    {
        m_tElements[3] = tW;
    }

    template <uint32_t Size, typename Type>
        inline double Vector<Size, Type>::length(void) const throw()
    {
        return sqrt(lengthSquared());
    }

    template <uint32_t Size, typename Type>
        inline double Vector<Size, Type>::lengthSquared(void) const throw()
    {
        double result = 0.0f;
        for(uint32_t ct = 0; ct < Size; ++ct)
        {
            result += m_tElements[ct] * m_tElements[ct];
        }
        return result;
    }

    template <uint32_t Size, typename Type>
        inline double Vector<Size, Type>::angleTo(const Vector<Size, Type>& vector) const throw()
    {
        return acos(dot(vector) / (vector.length() * this->length()));
    }

    template <uint32_t Size, typename Type>
        inline Vector<Size, Type> Vector<Size, Type>::cross(const Vector<Size, Type>& vector) const throw()
    {
        Type i = vector.getZ() * this->getY() - vector.getY() * this->getZ();
        Type j = vector.getX() * this->getZ() - vector.getZ() * this->getX();
        Type k = vector.getY() * this->getX() - vector.getX() * this->getY();
        return Vector<Size, Type>(i,j,k);
    }

    template <uint32_t Size, typename Type>
    inline Type Vector<Size, Type>::dot(const Vector<Size, Type>& rhs) const throw()
    {
        Type dotProduct = static_cast<Type>(0);
        for(uint32_t ct = 0; ct < Size; ++ct)
        {
            dotProduct += m_tElements[ct] * rhs.m_tElements[ct];
        }
        return dotProduct;
    }

    template <uint32_t Size, typename Type>
        inline void Vector<Size, Type>::normalise(void) throw()
    {
        double length = this->length();
        //FIXME - throw div by zero exception?
        if(length < 0.0001f)
        {
            return;
        }
        for(uint32_t ct = 0; ct < Size; ++ct)
        {
            m_tElements[ct] /= static_cast<Type>(length);
        }
    }
}//namespace PolyVox