AffVector.h

Go to the documentation of this file.

#ifndef AFFVECTOR_H
#define AFFVECTOR_H

#include <math.h>
#include <iostream>

namespace cryph
{
class AffPoint;

// indices for extracting components from vectors

const int DX = 0;
const int DY = 1;
const int DZ = 2;
const int DW = 3;

class AffVector
{
public:
    AffVector();

    AffVector(const AffVector& v);

    AffVector(const AffPoint& p);

    AffVector(double Dx, double Dy, double Dz=0.0);

    AffVector(const double xyz[]);

    AffVector(const float xyz[]);

    virtual ~AffVector();

    AffVector operator=(const AffVector& rhs);

    AffVector operator+=(const AffVector& rhs);

    AffVector operator-=(const AffVector& rhs);

    AffVector operator*=(double f);

    AffVector operator/=(double f);

    double operator[](int index) const;

    AffVector   operator+(const AffVector& v2) const
                { return AffVector(dx+v2.dx , dy+v2.dy , dz+v2.dz); }

    AffVector   operator-(const AffVector& v2) const
                { return AffVector(dx-v2.dx , dy-v2.dy , dz-v2.dz); }

    AffVector   operator-() const { return AffVector(-dx, -dy, -dz); }

    AffVector   operator*(double f) const
                { return AffVector(f*dx , f*dy , f*dz); }

    AffVector   operator/(double f) const
                { return AffVector(dx/f , dy/f , dz/f); }

    void arbitraryNormal(AffVector& normal) const;

    void assign(double dxx, double dyy, double dzz);

    AffVector cross(const AffVector& rhs) const;

    void decompose(const AffVector& arbitraryVector,
                    AffVector& parallel, AffVector& perpendicular) const;

    double dot(const AffVector& rhs) const
                { return dx*rhs.dx + dy*rhs.dy + dz*rhs.dz; }

    double length() const { return sqrt(lengthSquared()); }

    double lengthSquared() const { return dx*dx + dy*dy + dz*dz; }

    double maxAbsComponent(int& componentIndex) const;

    double minAbsComponent(int& componentIndex) const;

    double normalize();

    double normalizeToCopy(AffVector& normalizedCopy) const;

    bool parallelTo(const AffVector& v) const;

    void swizzle(char xyz[3]);

    double* vComponents(double* components, int offset=0) const;

    double* vComponents(double components[][3], int offset=0) const;

    float* vComponents(float* components, int offset=0) const;

    float* vComponents(float components[][3], int offset=0) const;

    static void coordinateSystemFromUW(AffVector& U, AffVector& V,
                    AffVector& W);

    static void coordinateSystemFromVW(AffVector& U, AffVector& V,
                    AffVector& W);

    static AffVector cross(const AffVector& v1, const AffVector& v2);

    static double dot(const AffVector& v1, const AffVector& v2)
                    { return v1.dx*v2.dx + v1.dy*v2.dy + v1.dz*v2.dz; }

    static const AffVector xu; 
    static const AffVector yu; 
    static const AffVector zu; 
    static const AffVector zeroVector; 
    // The vector components are public, but it is best to use the
    // other public methods whenever possible. Only use direct access
    // to these variables for ease of overwriting some specific
    // component.
    double  dx; 
    double  dy; 
    double  dz; 
};

std::ostream&   operator<<(std::ostream& os, const AffVector& v);
std::istream&   operator>>(std::istream& is, AffVector& v);

static AffVector operator*(double f, const AffVector& v)
    { return AffVector(f*v[DX] , f*v[DY] , f*v[DZ]); }
}

#endif