vector2.inl

Go to the documentation of this file.

/*
    Sheep - A Rigid Body Dynamics Engine
    Copyright (C) 2001-2004 Francois Beaune
    Contact: http://toxicengine.sourceforge.net/

    This file is part of Sheep.

    Sheep 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.

    Sheep 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 Sheep; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/

inline
Vector2::Vector2() {}

inline
Vector2::Vector2(Real r) :
    m_x(r), m_y(r) {}

inline
Vector2::Vector2(const Vector2 &v) :
    m_x(v.m_x), m_y(v.m_y) {}

inline
Vector2::Vector2(Real x, Real y) :
    m_x(x), m_y(y) {}

inline
Vector2 &Vector2::operator=(Real rhs) {
    m_x = m_y = rhs;

    return *this;
}

inline
Vector2 &Vector2::operator=(const Vector2 &rhs) {
    m_x = rhs.m_x;
    m_y = rhs.m_y;

    return *this;
}

inline
Real &Vector2::operator[](int i) {
    assert(i == 0 || i == 1);

    return *(&m_x + i);
}

inline
Real Vector2::SquareNorm() const {
    return m_x * m_x + m_y * m_y;
}

inline
Real Vector2::Norm() const {
    return sqrt(SquareNorm());
}

inline
Vector2 Vector2::Normalized() const {
    const Real n = Norm();
    return n == 0.0 ? Vector2(1.0, 0.0) : *this / n;
}

inline
void Vector2::Normalize() {
    const Real n = Norm();

    if(n == 0.0) {
        m_x = 1.0;
        m_y = 0.0;
    } else {
        m_x /= n;
        m_y /= n;
    }
}

inline
bool Vector2::IsUnitLength(Real e /*= EPS*/) const {
    return feq(SquareNorm(), 1.0, e);
}

inline
Vector2 operator+(const Vector2 &lhs, const Vector2 &rhs) {
    return Vector2(
        lhs.m_x + rhs.m_x,
        lhs.m_y + rhs.m_y);
}

inline
Vector2 operator-(const Vector2 &lhs, const Vector2 &rhs) {
    return Vector2(
        lhs.m_x - rhs.m_x,
        lhs.m_y - rhs.m_y);
}

inline
Vector2 operator-(const Vector2 &v) {
    return Vector2(-v.m_x, -v.m_y);
}

inline
Vector2 operator*(const Vector2 &lhs, Real rhs) {
    return Vector2(
        lhs.m_x * rhs,
        lhs.m_y * rhs);
}

inline
Vector2 operator*(Real lhs, const Vector2 &rhs) {
    return Vector2(
        lhs * rhs.m_x,
        lhs * rhs.m_y);
}

inline
Vector2 operator/(const Vector2 &lhs, Real rhs) {
    return Vector2(
        lhs.m_x / rhs,
        lhs.m_y / rhs);
}

inline
Vector2 &operator+=(Vector2 &lhs, const Vector2 &rhs) {
    lhs.m_x += rhs.m_x;
    lhs.m_y += rhs.m_y;

    return lhs;
}

inline
Vector2 &operator-=(Vector2 &lhs, const Vector2 &rhs) {
    lhs.m_x -= rhs.m_x;
    lhs.m_y -= rhs.m_y;

    return lhs;
}

inline
Vector2 &operator*=(Vector2 &lhs, Real rhs) {
    lhs.m_x *= rhs;
    lhs.m_y *= rhs;

    return lhs;
}

inline
Vector2 &operator/=(Vector2 &lhs, Real rhs) {
    lhs.m_x /= rhs;
    lhs.m_y /= rhs;

    return lhs;
}

inline
Real operator*(const Vector2 &lhs, const Vector2 &rhs) {
    return
        lhs.m_x * rhs.m_x +
        lhs.m_y * rhs.m_y;
}

---