vector4.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
Vector4::Vector4() {}

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

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

inline
Vector4::Vector4(Real x, Real y, Real z, Real w) :
    m_x(x),
    m_y(y),
    m_z(z),
    m_w(w) {}

inline
Vector4 &Vector4::operator=(Real r) {
    m_x = m_y = m_z = m_w = r;

    return *this;
}

inline
Vector4 &Vector4::operator=(const Vector4 &v) {
    m_x = v.m_x;
    m_y = v.m_y;
    m_z = v.m_z;
    m_w = v.m_w;

    return *this;
}

inline
Vector4 Vector4::operator+(const Vector4 &v) const {
    return Vector4(
        m_x + v.m_x,
        m_y + v.m_y,
        m_z + v.m_z,
        m_w + v.m_w);
}

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

inline
Vector4 Vector4::operator-() const {
    return Vector4(-m_x, -m_y, -m_z, -m_w);
}

inline
Vector4 Vector4::operator*(Real r) const {
    return Vector4(
        m_x * r,
        m_y * r,
        m_z * r,
        m_w * r);
}

inline
Vector4 Vector4::operator/(Real r) const {
    const Real inv_r = 1.0 / r;

    return Vector4(
        m_x * inv_r,
        m_y * inv_r,
        m_z * inv_r,
        m_w * inv_r);
}

inline
Vector4 &Vector4::operator+=(const Vector4 &v) {
    m_x += v.m_x;
    m_y += v.m_y;
    m_z += v.m_z;
    m_w += v.m_w;

    return *this;
}

inline
Vector4 &Vector4::operator-=(const Vector4 &v) {
    m_x -= v.m_x;
    m_y -= v.m_y;
    m_z -= v.m_z;
    m_w -= v.m_w;

    return *this;
}

inline
Vector4 &Vector4::operator*=(Real r) {
    m_x *= r;
    m_y *= r;
    m_z *= r;
    m_w *= r;

    return *this;
}

inline
Vector4 &Vector4::operator/=(Real r) {
    const Real inv_r = 1.0 / r;

    m_x *= inv_r;
    m_y *= inv_r;
    m_z *= inv_r;
    m_w *= inv_r;

    return *this;
}

inline
Real Vector4::operator*(const Vector4 &v) const {
    return
        m_x * v.m_x +
        m_y * v.m_y +
        m_z * v.m_z +
        m_w * v.m_w;
}

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

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

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

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

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

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

inline
Vector4 operator*(Real r, const Vector4 &v) {
    return v * r;
}

---