Vector3.cpp

/***************************************************************************
 *   This file is part of OpenCAL: Open Computer Animation Library         *
 *   I created OpenCAL as my master's thesis Computer Science (multimedia) *
 *   at the tUL university in Diepenbeek, Belgium                          *
 *                                                                         *
 *   Copyright (C) 2003-2004 by Jeroen Dierckx                             *
 *   jeroen.dierckx@student.luc.ac.be                                      *
 *                                                                         *
 ***************************************************************************/

// Includes
#include "Vector3.h"
#include <OpenCAL/Quaternion.h>
using namespace OpenCAL::Utils;

#include <math.h>

#include <ostream>
using namespace std;


// Static members
Vector3 Vector3::zero(0.0f, 0.0f, 0.0f);


/******************************
* Constructors and destructor *
******************************/

Vector3::Vector3()
{
    m_values[0] = 0.0f;
    m_values[1] = 0.0f;
    m_values[2] = 0.0f;
}

Vector3::Vector3(float x, float y, float z)
{
    m_values[0] = x;
    m_values[1] = y;
    m_values[2] = z;
}

Vector3::Vector3(float *values)
{
    m_values[0] = values[0];
    m_values[1] = values[1];
    m_values[2] = values[2];
}

Vector3::Vector3(const Vector3 &source)
{
    m_values[0] = source.m_values[0];
    m_values[1] = source.m_values[1];
    m_values[2] = source.m_values[2];
}

Vector3::~Vector3()
{
}


/************************
* Get and set functions *
************************/

void Vector3::set(float x, float y, float z)
{
    m_values[0] = x;
    m_values[1] = y;
    m_values[2] = z;
}

void Vector3::set(float *values)
{
    m_values[0] = values[0];
    m_values[1] = values[1];
    m_values[2] = values[2];
}

void Vector3::add(float x, float y, float z)
{
    m_values[0] += x;
    m_values[1] += y;
    m_values[2] += z;
}

void Vector3::add(float *values)
{
    m_values[0] += values[0];
    m_values[1] += values[1];
    m_values[2] += values[2];
}


/*********************
* Operator functions *
*********************/

Vector3 Vector3::operator+(const Vector3 &v) const
{
    return Vector3(
        m_values[0] + v.m_values[0],
        m_values[1] + v.m_values[1],
        m_values[2] + v.m_values[2]
    );
}

Vector3 Vector3::operator-(const Vector3 &v) const
{
    return Vector3(
        m_values[0] - v.m_values[0],
        m_values[1] - v.m_values[1],
        m_values[2] - v.m_values[2]
    );
}

Vector3 Vector3::operator-() const
{
    return Vector3(
        -m_values[0],
        -m_values[1],
        -m_values[2]
    );
}

Vector3 Vector3::operator*(float factor) const
{
    return Vector3(
        m_values[0] * factor,
        m_values[1] * factor,
        m_values[2] * factor
    );
}

Vector3 Vector3::operator/(float factor) const
{
    return Vector3(
        m_values[0] / factor,
        m_values[1] / factor,
        m_values[2] / factor
    );
}

void Vector3::operator+=(const Vector3 &v)
{
    m_values[0] += v.m_values[0];
    m_values[1] += v.m_values[1];
    m_values[2] += v.m_values[2];
}

void Vector3::operator-=(const Vector3 &v)
{
    m_values[0] -= v.m_values[0];
    m_values[1] -= v.m_values[1];
    m_values[2] -= v.m_values[2];
}

void Vector3::operator*=(float factor)
{
    m_values[0] *= factor;
    m_values[1] *= factor;
    m_values[2] *= factor;
}

void Vector3::operator/=(float factor)
{
    m_values[0] /= factor;
    m_values[1] /= factor;
    m_values[2] /= factor;
}

bool Vector3::operator==(const Vector3 &v)
{
    return (
        m_values[0] == v.m_values[0] &&
        m_values[1] == v.m_values[1] &&
        m_values[2] == v.m_values[2]
    );
}

bool Vector3::operator!=(const Vector3 &v)
{
    return (
        m_values[0] != v.m_values[0] ||
        m_values[1] != v.m_values[1] ||
        m_values[2] != v.m_values[2]
    );
}

// Friend functions
Vector3 OpenCAL::Utils::operator*(float factor, const Vector3 &v)
{
    return Vector3(
        v.m_values[0] * factor,
        v.m_values[1] * factor,
        v.m_values[2] * factor
    );
}

Vector3 OpenCAL::Utils::operator/(float factor, const Vector3 &v)
{
    return Vector3(
        factor / v.m_values[0],
        factor / v.m_values[1],
        factor / v.m_values[2]
    );
}


/******************
* Blend functions *
******************/

void Vector3::blend(float u, const Vector3 &source, const Vector3 &dest)
{
    *this += u * (dest - source);
}

Vector3 Vector3::blended(float u, const Vector3 &source, const Vector3 &dest) const
{
    return source + u * (dest - source);
}


/******************
* Other functions *
******************/

float Vector3::dotProduct(const Vector3 &v) const
{
    return (
        m_values[0] * v.m_values[0] +
        m_values[1] * v.m_values[1] +
        m_values[2] * v.m_values[2]
    );
}

Vector3 Vector3::crossProduct(const Vector3 &v) const
{
    return Vector3(
        m_values[1] * v.m_values[2] - m_values[2] * v.m_values[1],
        m_values[2] * v.m_values[0] - m_values[0] * v.m_values[2],
        m_values[0] * v.m_values[1] - m_values[1] * v.m_values[0]
    );
}

float Vector3::squaredLength() const
{
    return (
        m_values[0] * m_values[0] +
        m_values[1] * m_values[1] +
        m_values[2] * m_values[2]
    );
}

float Vector3::length() const
{
    return sqrtf(
        m_values[0] * m_values[0] +
        m_values[1] * m_values[1] +
        m_values[2] * m_values[2]
    );
}

float Vector3::distance(const Vector3 &v) const
{
    float dx = v.m_values[0] - m_values[0];
    float dy = v.m_values[1] - m_values[1];
    float dz = v.m_values[2] - m_values[2];

    return sqrtf(dx * dx + dy * dy + dz * dz);
}

float Vector3::squaredDistance(const Vector3 &v) const
{
    float dx = v.m_values[0] - m_values[0];
    float dy = v.m_values[1] - m_values[1];
    float dz = v.m_values[2] - m_values[2];

    return (dx * dx + dy * dy + dz * dz);
}

Vector3 Vector3::normalized() const
{
    float l = length();

    return Vector3(
        m_values[0] / l,
        m_values[1] / l,
        m_values[2] / l
    );
}

void Vector3::normalize()
{
    float l = length();

    m_values[0] /= l;
    m_values[1] /= l;
    m_values[2] /= l;
}

void Vector3::rotate(const Quaternion &rot)
{
    *this = rotated(rot);
}

Vector3 Vector3::rotated(const Quaternion &rot) const
{
    Quaternion v(0.0f, *this);

    return (rot * v * rot.inversed()).getVector();
}

void Vector3::rotated(const Quaternion &rot, Vector3 *result) const
{
    *result = rotated(rot);
}

Matrix33 Vector3::star() const
{
    return Matrix33(
        0, -m_values[2], m_values[1],
        m_values[2], 0, -m_values[0],
        -m_values[1], m_values[0], 0
    );
}

void Vector3::print() const
{
    cout << m_values[0] << ", " << m_values[1] << ", " << m_values[2] << endl;
}

ostream &OpenCAL::Utils::operator<<(ostream &stream, const Vector3 &v)
{
    stream << "(" << v.m_values[0] << ", " << v.m_values[1] << ", " << v.m_values[2] << ")";
    return stream;
}

---