SbVec.h

/*=======================================================================
 *** THE CONTENT OF THIS WORK IS PROPRIETARY TO FEI S.A.S, (FEI S.A.S.),            ***
 ***              AND IS DISTRIBUTED UNDER A LICENSE AGREEMENT.                     ***
 ***                                                                                ***
 ***  REPRODUCTION, DISCLOSURE,  OR USE,  IN WHOLE OR IN PART,  OTHER THAN AS       ***
 ***  SPECIFIED  IN THE LICENSE ARE  NOT TO BE  UNDERTAKEN  EXCEPT WITH PRIOR       ***
 ***  WRITTEN AUTHORIZATION OF FEI S.A.S.                                           ***
 ***                                                                                ***
 ***                        RESTRICTED RIGHTS LEGEND                                ***
 ***  USE, DUPLICATION, OR DISCLOSURE BY THE GOVERNMENT OF THE CONTENT OF THIS      ***
 ***  WORK OR RELATED DOCUMENTATION IS SUBJECT TO RESTRICTIONS AS SET FORTH IN      ***
 ***  SUBPARAGRAPH (C)(1) OF THE COMMERCIAL COMPUTER SOFTWARE RESTRICTED RIGHT      ***
 ***  CLAUSE  AT FAR 52.227-19  OR SUBPARAGRAPH  (C)(1)(II)  OF  THE RIGHTS IN      ***
 ***  TECHNICAL DATA AND COMPUTER SOFTWARE CLAUSE AT DFARS 52.227-7013.             ***
 ***                                                                                ***
 ***                   COPYRIGHT (C) 1996-2018 BY FEI S.A.S,                        ***
 ***                        BORDEAUX, FRANCE                                        ***
 ***                      ALL RIGHTS RESERVED                                       ***
**=======================================================================*/
/*=======================================================================
** Author      : VSG (MMM YYYY)
**=======================================================================*/
#ifndef _SB_VEC_
#define _SB_VEC_
 
#include <Inventor/SbBase.h>
#include <Inventor/SbMathHelper.h>
#include <Inventor/STL/iostream>
#include <string.h>
 
class SbVec2d;
class SbVec3d;
class SbVec3s;
class SbVec4d;
class SbPlane;
 
//
//  Class: SbVec2f
//
//  2D vector used to represent points or directions. Each component of
//  the vector is a float.
//
 
class  SbVec2f {
public:
 
  SbVec2f()    { memset(vec, 0, sizeof(vec)); }
 
  explicit SbVec2f(const float v[2])    { setValue(v); }
 
  SbVec2f(float x, float y)    { setValue(x, y); }
 
  SbVec2f(float val)    { setValue(val,val); }
 
  inline float  dot(const SbVec2f &v) const
  { return vec[0] * v.vec[0] + vec[1] * v.vec[1]; }
 
  const float  *getValue() const  { return vec; }
 
  void  getValue(float &x, float &y) const;
 
  float  length() const;
 
  inline float lengthSquared() const
  { return vec[0] * vec[0] + vec[1] * vec[1]; }
 
  void  negate();
 
  float  normalize();
 
  SbVec2f &setValue(const float v[2]);
 
  SbVec2f &setValue(float x, float y);
 
  SbVec2f &setValue(const SbVec2d &vec2d);
 
 
  float & operator [](int i) { return (vec[i]); }
  const float & operator [](int i) const   { return (vec[i]); }
 
  SbVec2f & operator *=(float d);
 
  inline SbVec2f operator *(const SbVec2f &v) const
  {
    return SbVec2f(vec[0]*v.vec[0],
                   vec[1]*v.vec[1]);
  }
 
  inline SbVec2f& operator *=(const SbVec2f &v)
  {
    *this = (*this)*v;
    return *this;
  }
 
  SbVec2f & operator /=(float d);
 
  SbVec2f & operator +=(const SbVec2f &u);
  SbVec2f & operator -=(const SbVec2f &u);
 
  SbVec2f operator -() const;
 
   friend SbVec2f operator *(const SbVec2f &v, float d);
   friend SbVec2f operator *(float d, const SbVec2f &v)
  { return v * d; }
   friend SbVec2f operator /(const SbVec2f &v, float d);
 
   friend SbVec2f operator +(const SbVec2f &v1, const SbVec2f &v2);
 
   friend SbVec2f operator -(const SbVec2f &v1, const SbVec2f &v2);
 
   friend int operator ==(const SbVec2f &v1, const SbVec2f &v2);
   friend int operator !=(const SbVec2f &v1, const SbVec2f &v2)
  { return !(v1 == v2); }
 
   friend inline std::ostream& operator << (std::ostream& os, const SbVec2f& v);
 
  SbBool equals(const SbVec2f& v, float tolerance) const;
 
  template<typename T>
  explicit SbVec2f(const T& v)
  {
    // Uses operator[](int) to get the required field and float() to convert it.
    vec[0] = float(v[0]);
    vec[1] = float(v[1]);
  }
 
private:
  float  vec[2];    // Storage for vector components
 
};
 
//
//  Class: SbVec2d
//
//  2D vector used to represet points or directions. Each component of
//  the vector is a double float.
//
 
class  SbVec2d {
public:
 
  SbVec2d()    { memset(vec, 0, sizeof(vec)); }
 
  explicit SbVec2d(const double v[2])    { setValue(v); }
 
  SbVec2d(double x, double y)    { setValue(x, y); }
 
  inline double  dot(const SbVec2d &v) const
  { return vec[0] * v.vec[0] + vec[1] * v.vec[1]; }
 
  const double  *getValue() const  { return vec; }
 
  void  getValue(double &x, double &y) const;
 
  double  length() const;
 
  inline double lengthSquared() const
  { return vec[0] * vec[0] + vec[1] * vec[1]; }
 
  void  negate();
 
  double  normalize();
 
  SbVec2d &setValue(const double v[2]);
 
  SbVec2d &setValue(double x, double y);
 
  SbVec2d &setValue(const SbVec2f &vec2f)
  { vec[0] = vec2f[0] ; vec[1] = vec2f[1] ; return (*this) ; }
 
 
  double & operator [](int i) { return (vec[i]); }
  const double & operator [](int i) const { return (vec[i]); }
 
  SbVec2d & operator *=(double d);
 
  SbVec2d & operator /=(double d);
 
  SbVec2d & operator +=(const SbVec2d &u);
  SbVec2d & operator -=(const SbVec2d &u);
 
  SbVec2d operator -() const;
 
   friend SbVec2d operator *(const SbVec2d &v, double d);
   friend SbVec2d operator *(double d, const SbVec2d &v)
  { return v * d; }
   friend SbVec2d operator /(const SbVec2d &v, double d);
 
   friend SbVec2d operator +(const SbVec2d &v1, const SbVec2d &v2);
 
   friend SbVec2d operator -(const SbVec2d &v1, const SbVec2d &v2);
 
   friend int operator ==(const SbVec2d &v1, const SbVec2d &v2);
   friend int operator !=(const SbVec2d &v1, const SbVec2d &v2)
  { return !(v1 == v2); }
 
  SbBool equals(const SbVec2d& v, double tolerance) const;
 
   friend inline std::ostream& operator << (std::ostream& os, const SbVec2d& v);
 
  template<typename T>
  explicit SbVec2d(const T& v)
  {
   // Uses operator[](int) to get the required field and double() to convert it.
   vec[0] = double(v[0]);
   vec[1] = double(v[1]);
  }
 
private:
  double  vec[2];    // Storage for vector components
 
};
 
//
//  Class: SbVec2i32
//
//  2D vector used to represent points or directions. Each component of
//  the vector is a (int32_t) integer.
//
 
class  SbVec2i32 {
public:
  SbVec2i32()    { memset(vec, 0, sizeof(vec)); }
  explicit SbVec2i32(const int32_t v[2]) { setValue(v); }
  SbVec2i32(int32_t x, int32_t y) { setValue(x, y); }
  inline int32_t dot(const SbVec2i32 &v) const
  { return vec[0] * v.vec[0] + vec[1] * v.vec[1]; }
  const int32_t *getValue() const { return vec; }
  void getValue(int32_t &x, int32_t &y) const;
  void negate();
  SbVec2i32 &setValue(const int32_t v[2]);
  SbVec2i32 &setValue(int32_t x, int32_t y);
  int32_t & operator [](int i) { return (vec[i]); }
  const int32_t & operator [](int i) const { return (vec[i]); }
  SbVec2i32 & operator *=(int d);
  SbVec2i32 & operator *=(double d);
 
  SbVec2i32 & operator /=(int d);
  SbVec2i32 & operator /=(double d)
  { return *this *= (1.0 / d); }
  SbVec2i32 & operator +=(const SbVec2i32 &u);
  SbVec2i32 & operator -=(const SbVec2i32 &u);
  SbVec2i32 operator -() const;
   friend SbVec2i32 operator *(const SbVec2i32 &v, int d);
   friend SbVec2i32 operator *(const SbVec2i32 &v, double d);
   friend SbVec2i32 operator *(int d, const SbVec2i32 &v)
  { return v * d; }
   friend SbVec2i32 operator *(double d, const SbVec2i32 &v)
  { return v * d; }
   friend SbVec2i32 operator /(const SbVec2i32 &v, int d);
   friend SbVec2i32 operator /(const SbVec2i32 &v, double d)
  { return v * (1.0 / d); }
   friend SbVec2i32 operator +(const SbVec2i32 &v1, const SbVec2i32 &v2);
   friend SbVec2i32 operator -(const SbVec2i32 &v1, const SbVec2i32 &v2);
   friend int operator ==(const SbVec2i32 &v1, const SbVec2i32 &v2);
   friend int operator !=(const SbVec2i32 &v1, const SbVec2i32 &v2)
  { return !(v1 == v2); }
 
   friend inline std::ostream& operator << (std::ostream& os, const SbVec2i32& v);
 
  template<typename T>
  explicit SbVec2i32(const T& v)
  {
    // Uses operator[](int) to get the required field and int32_t() to convert it.
    vec[0] = int32_t(v[0]);
    vec[1] = int32_t(v[1]);
  }
 
 
 
private:
  int32_t  vec[2];    // Storage for vector components
};
 
//
//  Class: SbVec2s
//
//  2D vector used to represet points or directions. Each component of
//  the vector is a (short) integer.
//
 
class  SbVec2s {
public:
 
  SbVec2s()    { memset(vec, 0, sizeof(vec)); }
 
  explicit SbVec2s(const short v[2]) { setValue(v); }
 
  SbVec2s(short x, short y) { setValue(x, y); }
 
#ifndef OIV_DO_NOT_ALLOW_I32_TO_I16_AUTO_CAST
  explicit SbVec2s(const SbVec2i32 &v);
#endif
 
  inline int32_t dot(const SbVec2s &v) const
  { return vec[0] * v.vec[0] + vec[1] * v.vec[1]; }
 
  const short *getValue() const { return vec; }
 
  void getValue(short &x, short &y) const;
 
  void negate();
 
  SbVec2s &setValue(const short v[2]);
 
  SbVec2s &setValue(short x, short y);
 
 
  short & operator [](int i) { return (vec[i]); }
  const short & operator [](int i) const { return (vec[i]); }
 
  SbVec2s & operator *=(int d);
  SbVec2s & operator *=(double d);
 
  SbVec2s & operator /=(int d);
  SbVec2s & operator /=(double d)
  { return *this *= (1.0 / d); }
 
  SbVec2s & operator +=(const SbVec2s &u);
  SbVec2s & operator -=(const SbVec2s &u);
 
  SbVec2s operator -() const;
 
#ifndef OIV_DO_NOT_ALLOW_I32_TO_I16_AUTO_CAST
  SbVec2s operator = (const SbVec2i32 &v);
#endif
 
   friend SbVec2s operator *(const SbVec2s &v, int d);
   friend SbVec2s operator *(const SbVec2s &v, double d);
   friend SbVec2s operator *(int d, const SbVec2s &v)
  { return v * d; }
   friend SbVec2s operator *(double d, const SbVec2s &v)
  { return v * d; }
   friend SbVec2s operator /(const SbVec2s &v, int d);
   friend SbVec2s operator /(const SbVec2s &v, double d)
  { return v * (1.0 / d); }
 
   friend SbVec2s operator +(const SbVec2s &v1, const SbVec2s &v2);
 
   friend SbVec2s operator -(const SbVec2s &v1, const SbVec2s &v2);
 
   friend int operator ==(const SbVec2s &v1, const SbVec2s &v2);
   friend int operator !=(const SbVec2s &v1, const SbVec2s &v2)
  { return !(v1 == v2); }
 
   friend inline std::ostream& operator << (std::ostream& os, const SbVec2s& v);
 
  template<typename T>
  explicit SbVec2s(const T& v)
  {
    // Uses operator[](int) to get the required field and short() to convert it.
    vec[0] = short(v[0]);
    vec[1] = short(v[1]);
  }
 
private:
  short  vec[2];    // Storage for vector components
 
};
 
//
//  Class: SbVec3f
//
//  3D vector used to represent points or directions. Each component of
//  the vector is a floating-point number.
//
//  WARNING!!!!!  Transcription of arrays of this class assume that the
//    only data stored in this class are three consecutive values.
//    Do not add any extra data members!!!
//
// Internal note:
// It would be convenient to have a conversion constructor that takes an SbVec3d
// (instead of having to create an SbVec3d and then call setValue).  But...
// This is not possible because given an expression like: "aVec3d * 1.2f"
// The compiler can't decide if it should convert the vector to SbVec3f or
// convert the constant to double.
//
 
class  SbVec3f {
public:
  SbVec3f()  { memset(vec, 0, sizeof(vec)); }
 
  explicit SbVec3f(const float v[3])
  { vec[0] = v[0]; vec[1] = v[1]; vec[2] = v[2]; }
 
  SbVec3f(float x, float y, float z)
  { vec[0] = x; vec[1] = y; vec[2] = z; }
 
  SbVec3f(SbPlane &p0, SbPlane &p1, SbPlane &p2);
 
  inline SbVec3f cross(const SbVec3f &v) const
  {
    return SbVec3f(
      vec[1] * v.vec[2] - vec[2] * v.vec[1],
          vec[2] * v.vec[0] - vec[0] * v.vec[2],
          vec[0] * v.vec[1] - vec[1] * v.vec[0]
    );
  }
 
  float  dot(const SbVec3f &v) const
  { return (vec[0] * v.vec[0] + vec[1] * v.vec[1] + vec[2] * v.vec[2]); }
 
  inline const float *getValue() const
  { return vec; }
 
  void getValue(float &x, float &y, float &z) const;
 
  float length() const;
 
  inline float lengthSquared() const
  { return vec[0] * vec[0] + vec[1] * vec[1] + vec[2] * vec[2]; }
 
  float  normalize();
 
  void  negate();
 
  inline SbVec3f &setValue(const float v[3])
  { vec[0] = v[0]; vec[1] = v[1]; vec[2] = v[2]; return *this; }
 
  inline  SbVec3f &setValue(float x, float y, float z)
  { vec[0] = x; vec[1] = y; vec[2] = z; return *this; }
 
  SbVec3f &setValue(const SbVec3f &barycentic, const SbVec3f &v0, const SbVec3f &v1, const SbVec3f &v2);
 
  SbVec3f &setValue(const SbVec3d &vec3d);
 
 
  float & operator [](int i) { return (vec[i]); }
  const float & operator [](int i) const  { return (vec[i]); }
 
  SbVec3f & operator *=(float d);
 
  SbVec3f & operator /=(float d);
 
  inline SbVec3f & operator +=(const SbVec3f &v)
  {
    vec[0] += v.vec[0];
    vec[1] += v.vec[1];
    vec[2] += v.vec[2];
 
    return *this;
  }
 
  SbVec3f & operator -=(const SbVec3f &v);
 
  inline SbVec3f operator -() const
  { return SbVec3f(-vec[0], -vec[1], -vec[2]); }
 
  inline SbVec3f operator *(const SbVec3f &v) const
  { return SbVec3f(vec[0]*v.vec[0], vec[1]*v.vec[1], vec[2]*v.vec[2]); }
 
  inline SbVec3f& operator *=(const SbVec3f &v)
  {
    *this = (*this)*v;
    return *this;
  }
 
   friend inline SbVec3f operator *(const SbVec3f &v, float d)
  { return SbVec3f(v.vec[0] * d, v.vec[1] * d, v.vec[2] * d); }
 
   friend inline SbVec3f operator *(float d, const SbVec3f &v)
  { return v * d; }
 
   friend inline SbVec3f operator /(const SbVec3f &v, float d)
  { return SbVec3f(v.vec[0] / d, v.vec[1] / d, v.vec[2] / d); }
 
   friend inline SbVec3f operator +(const SbVec3f &v1, const SbVec3f &v2)
  { return SbVec3f(v1.vec[0] + v2.vec[0], v1.vec[1] + v2.vec[1], v1.vec[2] + v2.vec[2]); }
 
   friend inline SbVec3f operator -(const SbVec3f &v1, const SbVec3f &v2)
  { return SbVec3f(v1.vec[0] - v2.vec[0], v1.vec[1] - v2.vec[1], v1.vec[2] - v2.vec[2]); }
 
   friend inline int operator ==(const SbVec3f &v1, const SbVec3f &v2)
  { return (v1.vec[0] == v2.vec[0] && v1.vec[1] == v2.vec[1] && v1.vec[2] == v2.vec[2]); }
 
   friend inline int operator !=(const SbVec3f &v1, const SbVec3f &v2)
  { return !(v1 == v2); }
 
   friend inline std::ostream& operator << (std::ostream& os, const SbVec3f& v);
 
  SbBool    equals(const SbVec3f& v, float tolerance) const;
 
  SbVec3f    getClosestAxis() const;
 
  template<typename T>
  explicit SbVec3f(const T& v)
  {
    // Uses operator[](int) to get the required field and float() to convert it.
    vec[0] = float(v[0]);
    vec[1] = float(v[1]);
    vec[2] = float(v[2]);
  }
 
private:
  float vec[3];    // Storage for vector components
 
};
 
//
//  Class: SbVec3d
//
//  3D vector used to represent points or directions. Each component of
//  the vector is a double precision floating-point number.
//
//  WARNING!!!!!  Transcription of arrays of this class assume that the
//    only data stored in this class are three consecutive values.
//    Do not add any extra data members!!!
//
// Internal note:
// It would be convenient to have a conversion constructor that takes an SbVec3d
// (instead of having to create an SbVec3d and then call setValue).  But...
// This is not possible because given an expression like: "aVec3d * 1.2f"
// The compiler can't decide if it should convert the vector to SbVec3f or
// convert the constant to double.
//
 
class  SbVec3d {
public:
  SbVec3d()  { memset(vec, 0, sizeof(vec)); }
 
  explicit SbVec3d(const double v[3])
  { vec[0] = v[0]; vec[1] = v[1]; vec[2] = v[2]; }
 
  inline SbVec3d(double x, double y, double z)
  { vec[0] = x; vec[1] = y; vec[2] = z; }
 
  SbVec3d(SbPlane &p0, SbPlane &p1, SbPlane &p2);
 
  inline SbVec3d cross(const SbVec3d &v) const
  {
    return SbVec3d(
      vec[1] * v.vec[2] - vec[2] * v.vec[1],
      vec[2] * v.vec[0] - vec[0] * v.vec[2],
      vec[0] * v.vec[1] - vec[1] * v.vec[0]
    );
  }
 
  inline double  dot(const SbVec3d &v) const
  { return (vec[0] * v.vec[0] + vec[1] * v.vec[1] + vec[2] * v.vec[2]); }
 
  inline const double  *getValue() const
  { return vec; }
 
  void  getValue(double &x, double &y, double &z) const;
 
  double  length() const;
 
  inline double lengthSquared() const
  { return vec[0] * vec[0] + vec[1] * vec[1] + vec[2] * vec[2]; }
 
  double  normalize();
 
  void  negate();
 
  SbVec3d &setValue(const double v[3])
  { vec[0] = v[0]; vec[1] = v[1]; vec[2] = v[2]; return *this; }
 
  SbVec3d &setValue(double x, double y, double z)
  { vec[0] = x; vec[1] = y; vec[2] = z; return *this; }
 
  SbVec3d &setValue(const SbVec3d &barycentic,
    const SbVec3d &v0,
    const SbVec3d &v1,
    const SbVec3d &v2);
 
  inline SbVec3d &setValue(const SbVec3f &vec3f)
  { vec[0] = vec3f[0] ; vec[1] = vec3f[1] ; vec[2] = vec3f[2] ; return (*this) ; }
 
 
  double & operator [](int i) { return (vec[i]); }
  const double & operator [](int i) const  { return (vec[i]); }
 
  inline SbVec3d & operator *=(double d)
  {
    vec[0] *= d;
    vec[1] *= d;
    vec[2] *= d;
 
    return *this;
  }
 
  inline SbVec3d & operator /=(double d)
  {
    vec[0] /= d;
    vec[1] /= d;
    vec[2] /= d;
 
    return *this;
  }
 
  inline SbVec3d & operator +=(const SbVec3d &v)
  {
    vec[0] += v.vec[0];
    vec[1] += v.vec[1];
    vec[2] += v.vec[2];
 
    return *this;
  }
 
  inline SbVec3d & operator -=(const SbVec3d &v)
  {
    vec[0] -= v.vec[0];
    vec[1] -= v.vec[1];
    vec[2] -= v.vec[2];
 
    return *this;
  }
 
 
  inline SbVec3d operator -() const
  { return SbVec3d(-vec[0], -vec[1], -vec[2]); }
 
  inline SbVec3d operator *(const SbVec3d &v) const
  { return SbVec3d(vec[0]*v.vec[0], vec[1]*v.vec[1], vec[2]*v.vec[2]); }
 
  inline SbVec3d& operator *=(const SbVec3d &v)
  {
    *this = (*this)*v;
    return *this;
  }
 
   friend inline SbVec3d operator *(const SbVec3d &v, double d)
  { return SbVec3d(v.vec[0] * d, v.vec[1] * d, v.vec[2] * d); }
 
   friend inline SbVec3d operator *(double d, const SbVec3d &v)
  { return v * d; }
 
   friend inline SbVec3d operator /(const SbVec3d &v, double d)
  { return SbVec3d(v.vec[0] / d, v.vec[1] / d,  v.vec[2] / d); }
 
   friend inline SbVec3d operator +(const SbVec3d &v1, const SbVec3d &v2)
  { return SbVec3d(v1.vec[0] + v2.vec[0], v1.vec[1] + v2.vec[1], v1.vec[2] + v2.vec[2]); }
 
   friend inline SbVec3d operator -(const SbVec3d &v1, const SbVec3d &v2)
  { return SbVec3d(v1.vec[0] - v2.vec[0], v1.vec[1] - v2.vec[1], v1.vec[2] - v2.vec[2]); }
 
   friend inline int operator ==(const SbVec3d &v1, const SbVec3d &v2)
  { return (v1.vec[0] == v2.vec[0] && v1.vec[1] == v2.vec[1] && v1.vec[2] == v2.vec[2]); }
 
   friend int operator !=(const SbVec3d &v1, const SbVec3d &v2)
  { return !(v1 == v2); }
 
  SbBool equals(const SbVec3d& v, double tolerance) const;
 
   friend inline std::ostream& operator << (std::ostream& os, const SbVec3d& v);
 
  SbVec3d    getClosestAxis() const;
 
  template<typename T>
  explicit SbVec3d(const T& v)
  {
    // Uses operator[](int) to get the required field and double() to convert it.
    vec[0] = double(v[0]);
    vec[1] = double(v[1]);
    vec[2] = double(v[2]);
  }
 
private:
  double vec[3];    // Storage for vector components
 
};
 
// Note: This implementation must appear after the declaration of SbVec3d!
 
inline SbVec3f &SbVec3f::setValue(const SbVec3d &vec3d)
{
  vec[0] = static_cast<float>(vec3d[0]);
  vec[1] = static_cast<float>(vec3d[1]);
  vec[2] = static_cast<float>(vec3d[2]);
  return (*this);
}
 
//
//  Class: SbVec3i32
//
//  3D vector used to represet points or directions or dimensions. Each
//  component of the vector is a (int32_t) integer.
//
 
class  SbVec3i32 {
public:
  SbVec3i32()           { memset(vec, 0, sizeof(vec)); }
  explicit SbVec3i32(const int32_t v[3])       { setValue(v); }
  SbVec3i32(int32_t x, int32_t y, int32_t z)  { setValue(x, y, z); }
  SbVec3i32( const SbVec3s &vec );
  inline int32_t dot(const SbVec3i32 &v) const
  {
    return vec[0] * v.vec[0] + vec[1] * v.vec[1] + vec[2] * v.vec[2];
  }
 
  const int32_t *getValue() const       { return vec; }
  void getValue(int32_t &x, int32_t &y, int32_t &z) const;
  void    negate();
  inline SbVec3i32 &setValue(const int32_t v[3])
  {
    vec[0] = v[0];
    vec[1] = v[1];
    vec[2] = v[2];
 
    return (*this);
  }
 
  inline SbVec3i32 &setValue(int32_t x, int32_t y, int32_t z)
  {
    vec[0] = x;
    vec[1] = y;
    vec[2] = z;
 
    return (*this);
  }
 
  SbVec3i32 &setValue(const SbVec3s &v);
  SbVec3i32 operator = (const SbVec3s &v);
  int32_t & operator [](int i)    { return (vec[i]); }
  const int32_t & operator [](int i) const  { return (vec[i]); }
  SbVec3i32 & operator *=(int d);
  SbVec3i32 & operator *=(double d);
 
  SbVec3i32 & operator /=(int d);
  SbVec3i32 & operator /=(double d)
  { return *this *= (1.0 / d); }
  inline SbVec3i32 & operator +=(const SbVec3i32 &u)
  {
    vec[0] += u.vec[0];
    vec[1] += u.vec[1];
    vec[2] += u.vec[2];
 
    return *this;
  }
  inline SbVec3i32 & operator /=(const SbVec3i32 &u)
  {
    vec[0] /= u.vec[0];
    vec[1] /= u.vec[1];
    vec[2] /= u.vec[2];
 
    return *this;
  }
  SbVec3i32 & operator -=(const SbVec3i32 &u);
  SbVec3i32 operator -() const;
  inline SbVec3i32 operator *(int d) const
  {
    return SbVec3i32(vec[0] * d, vec[1] * d, vec[2] * d);
  }
 
  inline SbVec3i32 operator *(const SbVec3i32 &v) const
  {
    return SbVec3i32(vec[0]*v.vec[0],
      vec[1]*v.vec[1],
      vec[2]*v.vec[2]);
  }
 
  inline SbVec3i32& operator *=(const SbVec3i32 &v)
  {
    *this = (*this)*v;
    return *this;
  }
 
   friend SbVec3i32 operator *(const SbVec3i32 &v, double d);
   friend SbVec3i32 operator *(int d, const SbVec3i32 &v)
  { return v * d; }
   friend SbVec3i32 operator *(double d, const SbVec3i32 &v)
  { return v * d; }
   friend SbVec3i32 operator /(const SbVec3i32 &v, int d);
   friend SbVec3i32 operator /(const SbVec3i32 &v, double d)
  { return v * (1.0 / d); }
  inline SbVec3i32 operator +(const SbVec3i32 &v) const
  {
    return SbVec3i32(vec[0] + v.vec[0],
                     vec[1] + v.vec[1],
                     vec[2] + v.vec[2]);
  }
 
   friend SbVec3i32 operator -(const SbVec3i32 &v1, const SbVec3i32 &v2)
  {
    return SbVec3i32(v1.vec[0] - v2.vec[0],
                     v1.vec[1] - v2.vec[1],
                     v1.vec[2] - v2.vec[2]);
  }
 
   friend int operator ==(const SbVec3i32 &v1, const SbVec3i32 &v2);
   friend int operator !=(const SbVec3i32 &v1, const SbVec3i32 &v2)
  { return !(v1 == v2); }
 
   friend inline std::ostream& operator << (std::ostream& os, const SbVec3i32& v);
 
  template<typename T>
  explicit SbVec3i32(const T& v)
  {
    // Uses operator[](int) to get the required field and int32_t() to convert it.
    vec[0] = int32_t(v[0]);
    vec[1] = int32_t(v[1]);
    vec[2] = int32_t(v[2]);
  }
 
  inline int32_t getMaxComponent() const;
 
private:
  int32_t   vec[3];     // Storage for vector components
};
 
int32_t
SbVec3i32::getMaxComponent() const
{
  return SbMathHelper::Max(SbMathHelper::Max(vec[0], vec[1]), vec[2]);
}
 
//
//  Class: SbVec3s
//
//  3D vector used to represet points or directions or dimensions. Each
//  component of the vector is a (short) integer.
//
 
 
 
class  SbVec3s {
public:
 
  SbVec3s()           { memset(vec, 0, sizeof(vec)); }
 
  explicit SbVec3s(const short v[3])       { setValue(v); }
 
  SbVec3s(short x, short y, short z)  { setValue(x, y, z); }
 
#ifndef OIV_DO_NOT_ALLOW_I32_TO_I16_AUTO_CAST
  SbVec3s(const SbVec3i32 &v);
#endif
 
  inline int32_t dot(const SbVec3s &v) const
  { return vec[0] * v.vec[0] + vec[1] * v.vec[1] + vec[2] * v.vec[2]; }
 
  const short *getValue() const       { return vec; }
 
  void getValue(short &x, short &y, short &z) const;
 
  void    negate();
 
  SbVec3s &setValue(const short v[3]);
 
  SbVec3s &setValue(short x, short y, short z);
 
 
  short & operator [](int i)    { return (vec[i]); }
  const short & operator [](int i) const  { return (vec[i]); }
 
  SbVec3s & operator *=(int d);
  SbVec3s & operator *=(double d);
 
  SbVec3s & operator /=(int d);
  SbVec3s & operator /=(double d)
  { return *this *= (1.0 / d); }
 
  SbVec3s & operator +=(const SbVec3s &u);
  SbVec3s & operator -=(const SbVec3s &u);
 
  SbVec3s operator -() const;
 
#ifndef OIV_DO_NOT_ALLOW_I32_TO_I16_AUTO_CAST
  SbVec3s operator = (const SbVec3i32 &v);
#endif
 
   friend SbVec3s operator *(const SbVec3s &v, int d);
   friend SbVec3s operator *(const SbVec3s &v, double d);
   friend SbVec3s operator *(int d, const SbVec3s &v)
  { return v * d; }
   friend SbVec3s operator *(double d, const SbVec3s &v)
  { return v * d; }
   friend SbVec3s operator /(const SbVec3s &v, int d);
   friend SbVec3s operator /(const SbVec3s &v, double d)
  { return v * (1.0 / d); }
 
   friend SbVec3s operator +(const SbVec3s &v1, const SbVec3s &v2);
 
   friend SbVec3s operator -(const SbVec3s &v1, const SbVec3s &v2);
 
   friend int operator ==(const SbVec3s &v1, const SbVec3s &v2);
   friend int operator !=(const SbVec3s &v1, const SbVec3s &v2)
  { return !(v1 == v2); }
 
   friend inline std::ostream& operator << (std::ostream& os, const SbVec3s& v);
 
  template<typename T>
  explicit SbVec3s(const T& v)
  {
    // Uses operator[](int) to get the required field and short() to convert it.
    vec[0] = short(v[0]);
    vec[1] = short(v[1]);
    vec[2] = short(v[2]);
  }
 
 
private:
  short   vec[3];     // Storage for vector components
 
};
 
//
//  Class: SbVec4b
//
//  4D vector. Each component of the vector is a (byte) integer.
//
 
 
 
class  SbVec4b {
public:
 
  SbVec4b()           { memset(vec, 0, sizeof(vec)); }
 
  explicit SbVec4b(const char v[4])       { setValue(v); }
 
  SbVec4b(char x, char y, char z, char w)  { setValue(x, y, z, w); }
 
  inline int32_t dot(const SbVec4b &v) const
  { return vec[0] * v.vec[0] + vec[1] * v.vec[1] + vec[2] * v.vec[2] + vec[3] * v.vec[3]; }
 
  const char *getValue() const       { return vec; }
 
  void getValue(char &x, char &y, char &z, char &w) const;
 
  void    negate();
 
  SbVec4b &setValue(const char v[4]);
 
  SbVec4b &setValue(char x, char y, char z, char w);
 
 
  char & operator [](int i)    { return (vec[i]); }
  const char & operator [](int i) const  { return (vec[i]); }
 
  SbVec4b & operator *=(int d);
  SbVec4b & operator *=(double d);
 
  SbVec4b & operator /=(int d);
  SbVec4b & operator /=(double d)
  { return *this *= (1.0 / d); }
 
  SbVec4b & operator +=(const SbVec4b &u);
  SbVec4b & operator -=(const SbVec4b &u);
 
  SbVec4b operator -() const;
 
   friend SbVec4b operator *(const SbVec4b &v, int d);
   friend SbVec4b operator *(const SbVec4b &v, double d);
   friend SbVec4b operator *(int d, const SbVec4b &v)
  { return v * d; }
   friend SbVec4b operator *(double d, const SbVec4b &v)
  { return v * d; }
   friend SbVec4b operator /(const SbVec4b &v, int d);
   friend SbVec4b operator /(const SbVec4b &v, double d)
  { return v * (1.0 / d); }
 
   friend SbVec4b operator +(const SbVec4b &v1, const SbVec4b &v2);
 
   friend SbVec4b operator -(const SbVec4b &v1, const SbVec4b &v2);
 
   friend int operator ==(const SbVec4b &v1, const SbVec4b &v2);
   friend int operator !=(const SbVec4b &v1, const SbVec4b &v2)
  { return !(v1 == v2); }
 
   friend inline std::ostream& operator << (std::ostream& os, const SbVec4b& v);
 
  template<typename T>
  explicit SbVec4b(const T& v)
  {
    // Uses operator[](int) to get the required field and char() to convert it.
    vec[0] = char(v[0]);
    vec[1] = char(v[1]);
    vec[2] = char(v[2]);
    vec[3] = char(v[3]);
  }
private:
  char   vec[4];     // Storage for vector components
 
};
 
//
//  Class: SbVec4f
//
//  4D vector used to represet rational points or directions. Each component of
//  the vector is a float.
//
 
class  SbVec4f {
public:
 
  SbVec4f()    { memset(vec, 0, sizeof(vec)); }
 
  explicit SbVec4f(const float v[4])    { setValue(v); }
 
  SbVec4f(float x, float y, float z, float w)    { setValue(x, y, z, w); }
 
  inline float  dot(const SbVec4f &v) const
  { return vec[0] * v.vec[0] + vec[1] * v.vec[1] + vec[2] * v.vec[2] + vec[3] * v.vec[3] ; }
 
  void  getReal(SbVec3f &v) const;
 
  const float  *getValue() const  { return vec; }
 
  void  getValue(float &x, float &y, float &z, float &w) const;
 
  float  length() const;
 
  inline float lengthSquared() const
  { return vec[0] * vec[0] + vec[1] * vec[1] + vec[2] * vec[2] + vec[3] * vec[3]; }
 
  void  negate();
 
  float  normalize();
 
  SbVec4f &setValue(const float v[4]);
 
  SbVec4f &setValue(float x, float y, float z, float w);
 
  SbVec4f &setValue(const SbVec4d &vec4d);
 
 
  float & operator [](int i) { return (vec[i]); }
  const float & operator [](int i) const  { return (vec[i]); }
 
  SbVec4f & operator *=(float d);
 
  SbVec4f & operator /=(float d);
 
  SbVec4f & operator +=(const SbVec4f &u);
  SbVec4f & operator -=(const SbVec4f &u);
 
  SbVec4f operator -() const;
 
   friend SbVec4f operator *(const SbVec4f &v, float d);
   friend SbVec4f operator *(float d, const SbVec4f &v)
  { return v * d; }
   friend SbVec4f operator /(const SbVec4f &v, float d);
 
   friend SbVec4f operator +(const SbVec4f &v1, const SbVec4f &v2);
 
   friend SbVec4f operator -(const SbVec4f &v1, const SbVec4f &v2);
 
   friend int operator ==(const SbVec4f &v1, const SbVec4f &v2);
   friend int operator !=(const SbVec4f &v1, const SbVec4f &v2)
  { return !(v1 == v2); }
 
   friend inline std::ostream& operator << (std::ostream& os, const SbVec4f& v);
 
  SbBool    equals(const SbVec4f& v, float tolerance) const;
 
  template<typename T>
  explicit SbVec4f(const T& v)
  {
    // Uses operator[](int) to get the required field and float() to convert it.
    vec[0] = float(v[0]);
    vec[1] = float(v[1]);
    vec[2] = float(v[2]);
    vec[3] = float(v[3]);
  }
 
private:
  float  vec[4];    // Storage for vector components
 
};
 
//
//  Class: SbVec4d
//
//  4D vector used to represet rational points or directions. Each component of
//  the vector is a double float.
//
 
class  SbVec4d {
public:
 
  SbVec4d()    { memset(vec, 0, sizeof(vec)); }
 
  explicit SbVec4d(const double v[4])    { setValue(v); }
 
  SbVec4d(double x, double y, double z, double w)    { setValue(x, y, z, w); }
 
  inline double  dot(const SbVec4d &v) const
  { return vec[0] * v.vec[0] + vec[1] * v.vec[1] + vec[2] * v.vec[2] + vec[3] * v.vec[3] ; }
 
  void  getReal(SbVec3d &v) const;
 
  const double  *getValue() const  { return vec; }
 
  void  getValue(double &x, double &y, double &z, double &w) const;
 
  double  length() const;
 
  inline double lengthSquared() const
  { return vec[0] * vec[0] + vec[1] * vec[1] + vec[2] * vec[2] + vec[3] * vec[3]; }
 
  void  negate();
 
  double  normalize();
 
  SbVec4d &setValue(const double v[4]);
 
  SbVec4d &setValue(double x, double y, double z, double w);
 
  SbVec4d &setValue(const SbVec4f &vec4f)
  { vec[0] = vec4f[0] ; vec[1] = vec4f[1] ; vec[2] = vec4f[2] ;
  vec[3] = vec4f[3] ; return (*this) ;}
 
 
  double & operator [](int i) { return (vec[i]); }
  const double & operator [](int i) const  { return (vec[i]); }
 
  SbVec4d & operator *=(double d);
 
  SbVec4d & operator /=(double d);
 
  SbVec4d & operator +=(const SbVec4d &u);
  SbVec4d & operator -=(const SbVec4d &u);
 
  SbVec4d operator -() const;
 
   friend SbVec4d operator *(const SbVec4d &v, double d);
   friend SbVec4d operator *(double d, const SbVec4d &v)
  { return v * d; }
   friend SbVec4d operator /(const SbVec4d &v, double d);
 
   friend SbVec4d operator +(const SbVec4d &v1, const SbVec4d &v2);
 
   friend SbVec4d operator -(const SbVec4d &v1, const SbVec4d &v2);
 
   friend int operator ==(const SbVec4d &v1, const SbVec4d &v2);
   friend int operator !=(const SbVec4d &v1, const SbVec4d &v2)
  { return !(v1 == v2); }
 
   friend inline std::ostream& operator << (std::ostream& os, const SbVec4d& v);
 
  SbBool    equals(const SbVec4d& v, double tolerance) const;
 
  template<typename T>
  explicit SbVec4d(const T& v)
  {
    // Uses operator[](int) to get the required field and double() to convert it.
    vec[0] = double(v[0]);
    vec[1] = double(v[1]);
    vec[2] = double(v[2]);
    vec[3] = double(v[3]);
  }
 
 
private:
  double  vec[4];    // Storage for vector components
 
};
 
//
//  Class: SbVec4i32
//
//  4D vector used to represet rational points or directions. Each
//  component of the vector is a (int32_t) integer.
//
 
class  SbVec4i32 {
public:
  SbVec4i32()           { memset(vec, 0, sizeof(vec)); }
  explicit SbVec4i32(const int32_t v[4])       { setValue(v); }
  SbVec4i32(int32_t x, int32_t y, int32_t z, int32_t w)  { setValue(x, y, z, w); }
  inline int32_t dot(const SbVec4i32 &v) const
  { return vec[0] * v.vec[0] + vec[1] * v.vec[1] + vec[2] * v.vec[2] + vec[3] * v.vec[3]; }
  const int32_t *getValue() const       { return vec; }
  void getValue(int32_t &x, int32_t &y, int32_t &z, int32_t &w) const;
  void    negate();
  SbVec4i32 &setValue(const int32_t v[4]);
  SbVec4i32 &setValue(int32_t x, int32_t y, int32_t z, int32_t w);
  int32_t & operator [](int i)    { return (vec[i]); }
  const int32_t & operator [](int i) const  { return (vec[i]); }
  SbVec4i32 & operator *=(int d);
  SbVec4i32 & operator *=(double d);
 
  SbVec4i32 & operator /=(int d);
  SbVec4i32 & operator /=(double d)
  { return *this *= (1.0 / d); }
  SbVec4i32 & operator +=(const SbVec4i32 &u);
  SbVec4i32 & operator -=(const SbVec4i32 &u);
  SbVec4i32 operator -() const;
   friend SbVec4i32 operator *(const SbVec4i32 &v, int d);
   friend SbVec4i32 operator *(const SbVec4i32 &v, double d);
   friend SbVec4i32 operator *(int d, const SbVec4i32 &v)
  { return v * d; }
   friend SbVec4i32 operator *(double d, const SbVec4i32 &v)
  { return v * d; }
   friend SbVec4i32 operator /(const SbVec4i32 &v, int d);
   friend SbVec4i32 operator /(const SbVec4i32 &v, double d)
  { return v * (1.0 / d); }
   friend SbVec4i32 operator +(const SbVec4i32 &v1, const SbVec4i32 &v2);
   friend SbVec4i32 operator -(const SbVec4i32 &v1, const SbVec4i32 &v2);
   friend int operator ==(const SbVec4i32 &v1, const SbVec4i32 &v2);
   friend int operator !=(const SbVec4i32 &v1, const SbVec4i32 &v2)
  { return !(v1 == v2); }
 
   friend inline std::ostream& operator << (std::ostream& os, const SbVec4i32& v);
 
  template<typename T>
  explicit SbVec4i32(const T& v)
  {
    // Uses operator[](int) to get the required field and int32_t() to convert it.
    vec[0] = int32_t(v[0]);
    vec[1] = int32_t(v[1]);
    vec[2] = int32_t(v[2]);
    vec[3] = int32_t(v[3]);
  }
 
private:
  int32_t   vec[4];     // Storage for vector components
};
 
//
//  Class: SbVec4s
//
//  4D vector. Each component of the vector is a (short) integer.
//
 
 
 
class  SbVec4s {
public:
 
  SbVec4s()           { memset(vec, 0, sizeof(vec)); }
 
  explicit SbVec4s(const short v[4])       { setValue(v); }
 
  SbVec4s(short x, short y, short z, short w)  { setValue(x, y, z, w); }
 
  inline int32_t dot(const SbVec4s &v) const
  { return vec[0] * v.vec[0] + vec[1] * v.vec[1] + vec[2] * v.vec[2] + vec[3] * v.vec[3]; }
 
  const short *getValue() const       { return vec; }
 
  void getValue(short &x, short &y, short &z, short &w) const;
 
  void    negate();
 
  SbVec4s &setValue(const short v[4]);
 
  SbVec4s &setValue(short x, short y, short z, short w);
 
 
  short & operator [](int i)    { return (vec[i]); }
  const short & operator [](int i) const  { return (vec[i]); }
 
  SbVec4s & operator *=(int d);
  SbVec4s & operator *=(double d);
 
  SbVec4s & operator /=(int d);
  SbVec4s & operator /=(double d)
  { return *this *= (1.0 / d); }
 
  SbVec4s & operator +=(const SbVec4s &u);
  SbVec4s & operator -=(const SbVec4s &u);
 
  SbVec4s operator -() const;
 
   friend SbVec4s operator *(const SbVec4s &v, int d);
   friend SbVec4s operator *(const SbVec4s &v, double d);
   friend SbVec4s operator *(int d, const SbVec4s &v)
  { return v * d; }
   friend SbVec4s operator *(double d, const SbVec4s &v)
  { return v * d; }
   friend SbVec4s operator /(const SbVec4s &v, int d);
   friend SbVec4s operator /(const SbVec4s &v, double d)
  { return v * (1.0 / d); }
 
   friend SbVec4s operator +(const SbVec4s &v1, const SbVec4s &v2);
 
   friend SbVec4s operator -(const SbVec4s &v1, const SbVec4s &v2);
 
   friend int operator ==(const SbVec4s &v1, const SbVec4s &v2);
   friend int operator !=(const SbVec4s &v1, const SbVec4s &v2)
  { return !(v1 == v2); }
 
   friend inline std::ostream& operator << (std::ostream& os, const SbVec4s& v);
 
  template<typename T>
  explicit SbVec4s(const T& v)
  {
    // Uses operator[](int) to get the required field and short() to convert it.
    vec[0] = short(v[0]);
    vec[1] = short(v[1]);
    vec[2] = short(v[2]);
    vec[3] = short(v[3]);
  }
 
 
 
private:
  short   vec[4];     // Storage for vector components
 
};
 
//
//  Class: SbVec4ui32
//
//  4D vector. Each component of the vector is an (uint32_t) integer.
//
 
 
 
class  SbVec4ui32 {
public:
 
  SbVec4ui32()           { memset(vec, 0, sizeof(vec)); }
 
  explicit SbVec4ui32(const uint32_t v[4])       { setValue(v); }
 
  SbVec4ui32(uint32_t x, uint32_t y, uint32_t z, uint32_t w)
  { setValue(x, y, z, w); }
 
  inline int32_t dot(const SbVec4ui32 &v) const
  { return vec[0] * v.vec[0] + vec[1] * v.vec[1] + vec[2] * v.vec[2] + vec[3] * v.vec[3]; }
 
  const uint32_t *getValue() const       { return vec; }
 
  void getValue(uint32_t &x, uint32_t &y,
    uint32_t &z, uint32_t &w) const;
 
  SbVec4ui32 &setValue(const uint32_t v[4]);
 
  SbVec4ui32 &setValue(uint32_t x, uint32_t y,
    uint32_t z, uint32_t w);
 
 
  uint32_t & operator [](int i)    { return (vec[i]); }
  const uint32_t & operator [](int i) const  { return (vec[i]); }
 
  SbVec4ui32 & operator *=(int d);
  SbVec4ui32 & operator *=(double d);
 
  SbVec4ui32 & operator /=(int d);
  SbVec4ui32 & operator /=(double d)
  { return *this *= (1.0 / d); }
 
  SbVec4ui32 & operator +=(const SbVec4ui32 &u);
  SbVec4ui32 & operator -=(const SbVec4ui32 &u);
   friend SbVec4ui32 operator *(const SbVec4ui32 &v, int d);
   friend SbVec4ui32 operator *(const SbVec4ui32 &v, double d);
   friend SbVec4ui32 operator *(int d, const SbVec4ui32 &v)
  { return v * d; }
   friend SbVec4ui32 operator *(double d, const SbVec4ui32 &v)
  { return v * d; }
   friend SbVec4ui32 operator /(const SbVec4ui32 &v, int d);
   friend SbVec4ui32 operator /(const SbVec4ui32 &v, double d)
  { return v * (1.0 / d); }
 
   friend SbVec4ui32 operator +(const SbVec4ui32 &v1, const SbVec4ui32 &v2);
 
   friend SbVec4ui32 operator -(const SbVec4ui32 &v1, const SbVec4ui32 &v2);
 
   friend int operator ==(const SbVec4ui32 &v1, const SbVec4ui32 &v2);
   friend int operator !=(const SbVec4ui32 &v1, const SbVec4ui32 &v2)
  { return !(v1 == v2); }
 
   friend inline std::ostream& operator << (std::ostream& os, const SbVec4ui32& v);
 
  template<typename T>
  explicit SbVec4ui32(const T& v)
  {
    // Uses operator[](int) to get the required field and uint32_t() to convert it.
    vec[0] = uint32_t(v[0]);
    vec[1] = uint32_t(v[1]);
    vec[2] = uint32_t(v[2]);
    vec[3] = uint32_t(v[3]);
  }
private:
  uint32_t   vec[4];     // Storage for vector components
 
};
 
//
//  Class: SbVec4us
//
//  4D vector. Each component of the vector is an (unsigned short) integer.
//
 
 
 
class  SbVec4us {
public:
 
  SbVec4us()           { memset(vec, 0, sizeof(vec)); }
 
  explicit SbVec4us(const unsigned short v[4])       { setValue(v); }
 
  SbVec4us(unsigned short x, unsigned short y, unsigned short z, unsigned short w)
  { setValue(x, y, z, w); }
 
  inline int32_t dot(const SbVec4us &v) const
  { return vec[0] * v.vec[0] + vec[1] * v.vec[1] + vec[2] * v.vec[2] + vec[3] * v.vec[3]; }
 
  const unsigned short *getValue() const       { return vec; }
 
  void getValue(unsigned short &x, unsigned short &y, unsigned short &z, unsigned short &w) const;
 
  void    negate();
 
  SbVec4us &setValue(const unsigned short v[4]);
 
  SbVec4us &setValue(unsigned short x, unsigned short y, unsigned short z, unsigned short w);
 
 
  unsigned short & operator [](int i)    { return (vec[i]); }
  const unsigned short & operator [](int i) const  { return (vec[i]); }
 
  SbVec4us & operator *=(int d);
  SbVec4us & operator *=(double d);
 
  SbVec4us & operator /=(int d);
  SbVec4us & operator /=(double d)
  { return *this *= (1.0 / d); }
 
  SbVec4us & operator +=(const SbVec4us &u);
  SbVec4us & operator -=(const SbVec4us &u);
 
  SbVec4us operator -() const;
 
   friend SbVec4us operator *(const SbVec4us &v, int d);
   friend SbVec4us operator *(const SbVec4us &v, double d);
   friend SbVec4us operator *(int d, const SbVec4us &v)
  { return v * d; }
   friend SbVec4us operator *(double d, const SbVec4us &v)
  { return v * d; }
   friend SbVec4us operator /(const SbVec4us &v, int d);
   friend SbVec4us operator /(const SbVec4us &v, double d)
  { return v * (1.0 / d); }
 
   friend SbVec4us operator +(const SbVec4us &v1, const SbVec4us &v2);
 
   friend SbVec4us operator -(const SbVec4us &v1, const SbVec4us &v2);
 
   friend int operator ==(const SbVec4us &v1, const SbVec4us &v2);
   friend int operator !=(const SbVec4us &v1, const SbVec4us &v2)
  { return !(v1 == v2); }
 
   friend inline std::ostream& operator << (std::ostream& os, const SbVec4us& v);
 
  template<typename T>
  explicit SbVec4us(const T& v)
  {
    // Uses operator[](int) to get the required field and unsigned short() to convert it.
    vec[0] = static_cast<unsigned short>(v[0]);
    vec[1] = static_cast<unsigned short>(v[1]);
    vec[2] = static_cast<unsigned short>(v[2]);
    vec[3] = static_cast<unsigned short>(v[3]);
  }
private:
  unsigned short   vec[4];     // Storage for vector components
 
};
 
 
//
//  Class: SbVec4ub
//
//  4D vector. Each component of the vector is an (unsigned byte) integer.
//
 
 
 
class  SbVec4ub {
public:
 
  SbVec4ub()           { memset(vec, 0, sizeof(vec)); }
 
  explicit SbVec4ub(const unsigned char v[4])       { setValue(v); }
 
  SbVec4ub(unsigned char x, unsigned char y, unsigned char z, unsigned char w)
  { setValue(x, y, z, w); }
 
  inline int32_t dot(const SbVec4ub &v) const
  { return vec[0] * v.vec[0] + vec[1] * v.vec[1] + vec[2] * v.vec[2] + vec[3] * v.vec[3]; }
 
  const unsigned char *getValue() const       { return vec; }
 
  void getValue(unsigned char &x, unsigned char &y, unsigned char &z, unsigned char &w) const;
 
  void    negate();
 
  SbVec4ub &setValue(const unsigned char v[4]);
 
  SbVec4ub &setValue(unsigned char x, unsigned char y, unsigned char z, unsigned char w);
 
 
  unsigned char & operator [](int i)    { return (vec[i]); }
  const unsigned char & operator [](int i) const  { return (vec[i]); }
 
  SbVec4ub & operator *=(int d);
  SbVec4ub & operator *=(double d);
 
  SbVec4ub & operator /=(int d);
  SbVec4ub & operator /=(double d)
  { return *this *= (1.0 / d); }
 
  SbVec4ub & operator +=(const SbVec4ub &u);
  SbVec4ub & operator -=(const SbVec4ub &u);
 
  SbVec4ub operator -() const;
 
   friend SbVec4ub operator *(const SbVec4ub &v, int d);
   friend SbVec4ub operator *(const SbVec4ub &v, double d);
   friend SbVec4ub operator *(int d, const SbVec4ub &v)
  { return v * d; }
   friend SbVec4ub operator *(double d, const SbVec4ub &v)
  { return v * d; }
   friend SbVec4ub operator /(const SbVec4ub &v, int d);
   friend SbVec4ub operator /(const SbVec4ub &v, double d)
  { return v * (1.0 / d); }
 
   friend SbVec4ub operator +(const SbVec4ub &v1, const SbVec4ub &v2);
 
   friend SbVec4ub operator -(const SbVec4ub &v1, const SbVec4ub &v2);
 
   friend int operator ==(const SbVec4ub &v1, const SbVec4ub &v2);
   friend int operator !=(const SbVec4ub &v1, const SbVec4ub &v2)
  { return !(v1 == v2); }
 
   friend inline std::ostream& operator << (std::ostream& os, const SbVec4ub& v);
 
  template<typename T>
  explicit SbVec4ub(const T& v)
  {
    // Uses operator[](int) to get the required field and unsigned char() to convert it.
    vec[0] = static_cast<unsigned char>(v[0]);
    vec[1] = static_cast<unsigned char>(v[1]);
    vec[2] = static_cast<unsigned char>(v[2]);
    vec[3] = static_cast<unsigned char>(v[3]);
  }
 
  inline void clamp(unsigned char a, unsigned char b)
  {
    vec[0] = SbMathHelper::Clamp(vec[0], a, b);
    vec[1] = SbMathHelper::Clamp(vec[1], a, b);
    vec[2] = SbMathHelper::Clamp(vec[2], a, b);
    vec[3] = SbMathHelper::Clamp(vec[3], a, b);
  }
private:
  unsigned char   vec[4];     // Storage for vector components
 
};
 
inline std::ostream& operator << (std::ostream& os, const SbVec2s& v)
{
  return os << "(" << v[0] << ", " << v[1] << ")";
}
 
inline std::ostream& operator << (std::ostream& os, const SbVec2i32& v)
{
  return os << "(" << v[0] << ", " << v[1] << ")";
}
 
inline std::ostream& operator << (std::ostream& os, const SbVec2f& v)
{
  return os << "(" << v[0] << ", " << v[1] << ")";
}
 
inline std::ostream& operator << (std::ostream& os, const SbVec2d& v)
{
  return os << "(" << v[0] << ", " << v[1] << ")";
}
 
inline std::ostream& operator << (std::ostream& os, const SbVec3s& v)
{
  return os << "(" << v[0] << ", " << v[1] << ", " << v[2] << ")";
}
 
inline std::ostream& operator << (std::ostream& os, const SbVec3i32& v)
{
  return os << "(" << v[0] << ", " << v[1] << ", " << v[2] << ")";
}
 
inline std::ostream& operator << (std::ostream& os, const SbVec3d& v)
{
  return os << "(" << v[0] << ", " << v[1] << ", " << v[2] << ")";
}
 
inline std::ostream& operator << (std::ostream& os, const SbVec3f& v)
{
  return os << "(" << v[0] << ", " << v[1] << ", " << v[2] << ")";
}
 
 
inline std::ostream& operator << (std::ostream& os, const SbVec4b& v)
{
  return os << "(" << static_cast<int>(v[0]) << ", " << static_cast<int>(v[1]) << ", " << static_cast<int>(v[2]) << ", " << static_cast<int>(v[3]) << ")";
}
 
inline std::ostream& operator << (std::ostream& os, const SbVec4d& v)
{
  return os << "(" << v[0] << ", " << v[1] << ", " << v[2] << ", " << v[3] << ")";
}
 
inline std::ostream& operator << (std::ostream& os, const SbVec4f& v)
{
  return os << "(" << v[0] << ", " << v[1] << ", " << v[2] << ", " << v[3] << ")";
}
 
inline std::ostream& operator << (std::ostream& os, const SbVec4i32& v)
{
  return os << "(" << v[0] << ", " << v[1] << ", " << v[2] << ", " << v[3] << ")";
}
 
inline std::ostream& operator << (std::ostream& os, const SbVec4s& v)
{
  return os << "(" << v[0] << ", " << v[1] << ", " << v[2] << ", " << v[3] << ")";
}
 
inline std::ostream& operator << (std::ostream& os, const SbVec4ub& v)
{
  return os << "(" << static_cast<unsigned int>(v[0]) << ", " << static_cast<unsigned int>(v[1]) << ", " << static_cast<unsigned int>(v[2]) << ", " << static_cast<unsigned int>(v[3]) << ")";
}
 
inline std::ostream& operator << (std::ostream& os, const SbVec4ui32& v)
{
  return os << "(" << v[0] << ", " << v[1] << ", " << v[2] << ", " << v[3] << ")";
}
 
inline std::ostream& operator << (std::ostream& os, const SbVec4us& v)
{
  return os << "(" << v[0] << ", " << v[1] << ", " << v[2] << ", " << v[3] << ")";
}
 
 
#endif /* _SB_VEC_ */