Vector.cc

#include "Vector.hh"
 
namespace EGG {
 
f32 Vector2f::normalise() {
    f32 len = length();
    if (len != 0.0f) {
        *this = *this * (1.0f / len);
    }
 
    return len;
}
 
void Vector2f::normalise2() {
    f32 sqLen = dot();
    if (sqLen > std::numeric_limits<f32>::epsilon()) {
        *this *= EGG::Mathf::frsqrt(sqLen);
    }
}
 
void Vector2f::read(Stream &stream) {
    x = stream.read_f32();
    y = stream.read_f32();
}
 
f32 Vector3f::ps_dot() const {
    return ps_dot(*this);
}
 
f32 Vector3f::ps_dot(const Vector3f &rhs) const {
    f32 y_ = y * rhs.y;
    f32 xy = Mathf::fma(x, rhs.x, y_);
    return xy + z * rhs.z;
}
 
f32 Vector3f::ps_squareMag() const {
    f32 x_ = x * x;
    f32 zx = Mathf::fma(z, z, x_);
    return zx + y * y;
}
 
f32 Vector3f::normalise() {
    f32 len = 0.0f;
 
    if (squaredLength() > std::numeric_limits<f32>::epsilon()) {
        len = length();
        *this *= (1.0f / len);
    }
 
    return len;
}
 
EGG::Vector3f Vector3f::ps_normalize() const {
    f32 dot = Mathf::fma(z, z, x * x) + y * y;
    return *this * EGG::Mathf::frsqrt(dot);
}
 
std::pair<f32, EGG::Vector3f> Vector3f::ps_normalized() {
    f32 mag = ps_length();
    if (mag <= 0.0f) {
        return std::make_pair(mag, EGG::Vector3f::zero);
    }
 
    return std::make_pair(mag, *this * (1.0f / mag));
}
 
void Vector3f::normalise2() {
    f32 sqLen = squaredLength();
    if (sqLen > std::numeric_limits<f32>::epsilon()) {
        *this *= Mathf::frsqrt(sqLen);
    }
}
 
Vector3f Vector3f::maximize(const Vector3f &rhs) const {
    Vector3f out;
 
    out.x = x > rhs.x ? x : rhs.x;
    out.y = y > rhs.y ? y : rhs.y;
    out.z = z > rhs.z ? z : rhs.z;
 
    return out;
}
 
Vector3f Vector3f::minimize(const Vector3f &rhs) const {
    Vector3f out;
 
    out.x = x < rhs.x ? x : rhs.x;
    out.y = y < rhs.y ? y : rhs.y;
    out.z = z < rhs.z ? z : rhs.z;
 
    return out;
}
 
f32 Vector3f::ps_sqDistance(const Vector3f &rhs) const {
    const EGG::Vector3f diff = *this - rhs;
    return diff.ps_dot();
}
 
Vector3f Vector3f::perpInPlane(const EGG::Vector3f &rhs, bool normalise) const {
    if (Mathf::abs(dot(rhs)) == 1.0f) {
        return EGG::Vector3f::zero;
    }
 
    f32 _x = (rhs.z * x - rhs.x * z) * rhs.z - (rhs.x * y - rhs.y * x) * rhs.y;
    f32 _y = (rhs.x * y - rhs.y * x) * rhs.x - (rhs.y * z - rhs.z * y) * rhs.z;
    f32 _z = (rhs.y * z - rhs.z * y) * rhs.y - (rhs.z * x - rhs.x * z) * rhs.x;
 
    EGG::Vector3f ret(_x, _y, _z);
 
    if (normalise) {
        ret.normalise();
    }
 
    return ret;
}
 
void Vector3f::read(Stream &stream) {
    x = stream.read_f32();
    y = stream.read_f32();
    z = stream.read_f32();
}
 
} // namespace EGG