vector3.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
Vector3::Vector3() {}

inline
Vector3::Vector3(Real r) :
    m_x(r),
    m_y(r),
    m_z(r) {}

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

inline
Vector3::Vector3(Real x, Real y, Real z) :
    m_x(x),
    m_y(y),
    m_z(z) {}

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

    return *this;
}

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

    return *this;
}

inline
Real &Vector3::operator[](int i) {
    assert(i >= 0 && i < 3);

    return *(&m_x + i);
}

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

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

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

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

    if(n == 0.0) {
        m_x = 1.0;
        m_y = m_z = 0.0;
    } else {
        const Real inv_n = 1.0 / n;
        m_x *= inv_n;
        m_y *= inv_n;
        m_z *= inv_n;
    }
}

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

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

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

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

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

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

inline
Vector3 operator/(const Vector3 &lhs, Real rhs) {
    const Real inv_rhs = 1.0 / rhs;

    return Vector3(
        lhs.m_x * inv_rhs,
        lhs.m_y * inv_rhs,
        lhs.m_z * inv_rhs);
}

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

    return lhs;
}

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

    return lhs;
}

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

    return lhs;
}

inline
Vector3 &operator/=(Vector3 &lhs, Real rhs) {
    const Real inv_rhs = 1.0 / rhs;

    lhs.m_x *= inv_rhs;
    lhs.m_y *= inv_rhs;
    lhs.m_z *= inv_rhs;

    return lhs;
}

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

inline
Vector3 operator^(const Vector3 &lhs, const Vector3 &rhs) {
    return Vector3(
        lhs.m_y * rhs.m_z - rhs.m_y * lhs.m_z,
        lhs.m_z * rhs.m_x - rhs.m_z * lhs.m_x,
        lhs.m_x * rhs.m_y - rhs.m_x * lhs.m_y);
}

inline
bool feq(const Vector3 &a, const Vector3 &b, Real e /*= EPS*/) {
    return
        feq(a.m_x, b.m_x, e) &&
        feq(a.m_y, b.m_y, e) &&
        feq(a.m_z, b.m_z, e);
}

inline
bool fneq(const Vector3 &a, const Vector3 &b, Real e /*= EPS*/) {
    return
        fneq(a.m_x, b.m_x, e) ||
        fneq(a.m_y, b.m_y, e) ||
        fneq(a.m_z, b.m_z, e);
}

inline
bool fz(const Vector3 &a, Real e /*= EPS*/) {
    return
        fz(a.m_x, e) &&
        fz(a.m_y, e) &&
        fz(a.m_z, e);
}

inline
bool fnz(const Vector3 &a, Real e /*= EPS*/) {
    return
        fnz(a.m_x, e) ||
        fnz(a.m_y, e) ||
        fnz(a.m_z, e);
}

---