C++ API Reference
ik2Bsolver/AwVector.h
#ifndef _AwVector
#define _AwVector
//-
// ==========================================================================
// Copyright 2020 Autodesk, Inc. All rights reserved.
//
// Use of this software is subject to the terms of the Autodesk
// license agreement provided at the time of installation or download,
// or which otherwise accompanies this software in either electronic
// or hard copy form.
// ==========================================================================
//+
//
// CLASS: AwVector
//
// *****************************************************************************
//
// CLASS DESCRIPTION (AwVector)
//
// A vector is a mathematical entity used to express the notion of
// direction and magnitude (not to be confused with a point that expresses
// location). The direction is defined by the line from the origin
// to the vector's x, y, z coordinate. Vectors can be used to represent
// translations, in the way that quaternions are used to represent
// rotations. When vectors are used to represent a direction, multiplying
// it by a transformation matrix results in the vector being properly
// re-oriented by the transformation (eg. a pure translation doesn't affect
// the direction something is pointing, so a vector remains unchanged under
// a pure translation).
//
// *****************************************************************************
#if defined(__APPLE__)
#include <stdlib.h>
#endif
#include <AwMath.h>
#define kVectorEquivalentTolerance kDoubleEpsilon
class AwPoint;
class AwMatrix;
class AwQuaternion;
class AwVector {
public:
enum Axis {
kXaxis,
kYaxis,
kZaxis
};
AwVector();
AwVector(const AwVector &);
AwVector(const AwPoint &);
AwVector(double xx, double yy, double zz = 0.0);
#ifndef COMPILE_OUTSIDE_MAYA
AwVector(const MVector &);
#endif
~AwVector();
AwVector &operator=(const AwVector &);
AwVector &operator=(const AwMatrix &);
AwVector &set(double xx, double yy, double zz = 0.0);
double &operator[](size_t i);
double operator[](size_t i) const;
double operator*(const AwVector &right) const;
AwVector operator^(const AwVector &right) const;
double dotProduct(const AwVector &) const;
AwVector crossProduct(const AwVector &) const;
AwVector operator*(const AwMatrix &right) const;
AwVector &operator*=(const AwMatrix &right);
AwVector operator*(double) const;
AwVector operator+(const AwVector &) const;
AwVector operator-(const AwVector &) const;
AwVector operator-() const;
bool operator==(const AwVector &) const;
bool operator!=(const AwVector &) const;
double length() const;
double norm() const;
AwVector normal() const;
AwVector &normalize();
AwVector rotateBy(const AwQuaternion &) const;
bool isParallel(const AwVector &,
double = kVectorEquivalentTolerance) const;
Axis dominantAxis() const;
double angle(const AwVector &) const;
operator AwMatrix() const;
friend ostream &operator<<(ostream &os, const AwVector &);
static const AwVector zero; // The identity transformation.
static const AwVector xAxis; // The x axis
static const AwVector yAxis; // The y axis
static const AwVector zAxis; // The z axis
double x, y, z;
};
// Inline methods
inline AwVector::AwVector ()
: x(0.0), y(0.0), z(0.0) {}
inline AwVector::AwVector(const AwVector &v)
: x(v.x), y(v.y), z(v.z) {}
inline AwVector::AwVector(double xx, double yy, double zz)
: x(xx), y(yy), z(zz) {}
#ifndef COMPILE_OUTSIDE_MAYA
inline AwVector::AwVector(const MVector &v)
: x(v.x), y(v.y), z(v.z) {}
#endif
inline AwVector::~AwVector ()
{}
inline AwVector &AwVector::operator=(const AwVector &src)
{ x = src.x; y = src.y; z = src.z; return *this; }
inline AwVector &AwVector::set(double xx, double yy, double zz)
{ x = xx; y = yy; z = zz; return *this; }
inline double & AwVector::operator[](size_t i)
{ return (&x)[i]; }
inline double AwVector::operator[](size_t i) const
{ return (&x)[i]; }
inline double AwVector::dotProduct(const AwVector &v) const
{ return (x*v.x + y*v.y + z*v.z); }
inline AwVector AwVector::crossProduct(const AwVector &r) const
{ return AwVector(y*r.z - z*r.y, z*r.x - x*r.z, x*r.y - y*r.x); }
inline double AwVector::operator*(const AwVector &a) const
{ return dotProduct(a); }
inline AwVector AwVector::operator^(const AwVector &a) const
{ return crossProduct(a); }
inline AwVector AwVector::operator+(const AwVector &v) const
{ return AwVector(x + v.x, y + v.y, z + v.z); }
inline AwVector AwVector::operator-(const AwVector &v) const
{ return AwVector(x - v.x, y - v.y, z - v.z); }
inline AwVector &AwVector::operator*=(const AwMatrix &m)
{ *this = *this * m; return *this; }
inline AwVector AwVector::operator*(double s) const
{ return AwVector(x * s, y * s, z * s); }
inline AwVector AwVector::operator-() const
{ return AwVector(-x, -y, -z); }
inline bool AwVector::operator==(const AwVector &v) const
{ return (x == v.x && y == v.y && z == v.z); }
inline bool AwVector::operator!=(const AwVector &v) const
{ return !(*this == v); }
inline double AwVector::norm() const
{ return (x*x + y*y + z*z); }
inline double AwVector::length() const
{ return sqrt(norm()); }
inline AwVector AwVector::normal() const
{ AwVector tmp(*this); return tmp.normalize(); }
#endif // _AwVector