quath.h

Go to the documentation of this file.

//
// Copyright 2016 Pixar
//
// Licensed under the terms set forth in the LICENSE.txt file available at
// https://openusd.org/license.
//
// This file is generated by a script.  Do not edit directly.  Edit the
// quat.template.h file to make changes.
 
#ifndef PXR_BASE_GF_QUATH_H
#define PXR_BASE_GF_QUATH_H
 
 
#include "pxr/pxr.h"
#include "pxr/base/gf/api.h"
#include "pxr/base/gf/declare.h"
#include "pxr/base/gf/vec3h.h"
#include "pxr/base/gf/traits.h"
#include "pxr/base/gf/half.h"
#include "pxr/base/tf/hash.h"
 
#include <iosfwd>
 
PXR_NAMESPACE_OPEN_SCOPE
 
template <>
struct GfIsGfQuat<class GfQuath> { static const bool value = true; };
 
 
GfHalf GfDot(const GfQuath& q1, const GfQuath& q2);
 
 
class GfQuath
{
  public:
    typedef GfHalf ScalarType;
    typedef GfVec3h ImaginaryType;
 
    GfQuath() = default;
 
    explicit GfQuath (GfHalf realVal) : _imaginary(0), _real(realVal) {}
 
    GfQuath(GfHalf real, GfHalf i, GfHalf j, GfHalf k)
        : _imaginary(i, j, k), _real(real)
    {
    }
 
    GfQuath(GfHalf real, const GfVec3h &imaginary)
        : _imaginary(imaginary), _real(real)
    {
    }
 
    GF_API
    explicit GfQuath(class GfQuatd const &other);
    GF_API
    explicit GfQuath(class GfQuatf const &other);
 
    static GfQuath GetZero() { return GfQuath(0.0); }
 
    static GfQuath GetIdentity() { return GfQuath(1.0); }
 
    GfHalf GetReal() const { return _real; }
 
    void SetReal(GfHalf real) { _real = real; }
 
    const GfVec3h &GetImaginary() const { return _imaginary; }
 
    void SetImaginary(const GfVec3h &imaginary) {
        _imaginary = imaginary;
    }
 
    void SetImaginary(GfHalf i, GfHalf j, GfHalf k) {
        _imaginary.Set(i, j, k);
    }
 
    GfHalf GetLength() const { return GfSqrt(_GetLengthSquared()); }
 
    GfQuath
    GetNormalized(GfHalf eps = GF_MIN_VECTOR_LENGTH) const {
        GfQuath ret(*this);
        ret.Normalize(eps);
        return ret;
    }
 
    GF_API
    GfHalf Normalize(GfHalf eps = GF_MIN_VECTOR_LENGTH);
 
    GfQuath GetConjugate() const {
        return GfQuath(GetReal(), -GetImaginary());
    }
 
    GfQuath GetInverse() const {
        return GetConjugate() / _GetLengthSquared();
    }
 
    GF_API
    GfVec3h Transform(const GfVec3h& point) const;
 
    friend inline size_t hash_value(const GfQuath &q) {
        return TfHash::Combine(q.GetReal(), q.GetImaginary());
    }
 
    GfQuath operator-() const {
        return GfQuath(-GetReal(), -GetImaginary());
    }
 
    bool operator==(const GfQuath &q) const {
        return (GetReal() == q.GetReal() &&
                GetImaginary() == q.GetImaginary());
    }
 
    bool operator!=(const GfQuath &q) const {
        return !(*this == q);
    }
 
    GF_API
    GfQuath &operator *=(const GfQuath &q);
 
    GfQuath &operator *=(GfHalf s) {
        _real *= s;
        _imaginary *= s;
        return *this;
    }
 
    GfQuath &operator /=(GfHalf s) {
        _real /= s;
        _imaginary /= s;
        return *this;
    }
 
    GfQuath &operator +=(const GfQuath &q) {
        _real += q._real;
        _imaginary += q._imaginary;
        return *this;
    }
 
    GfQuath &operator -=(const GfQuath &q)  {
        _real -= q._real;
        _imaginary -= q._imaginary;
        return *this;
    }
 
    friend GfQuath
    operator +(const GfQuath &q1, const GfQuath &q2) {
        return GfQuath(q1) += q2;
    }
 
    friend GfQuath
    operator -(const GfQuath &q1, const GfQuath &q2) {
        return GfQuath(q1) -= q2;
    }
 
    friend GfQuath
    operator *(const GfQuath &q1, const GfQuath &q2) {
        return GfQuath(q1) *= q2;
    }
 
    friend GfQuath
    operator *(const GfQuath &q, GfHalf s) {
        return GfQuath(q) *= s;
    }
 
    friend GfQuath
    operator *(GfHalf s, const GfQuath &q) {
        return GfQuath(q) *= s;
    }
 
    friend GfQuath
    operator /(const GfQuath &q, GfHalf s) {
        return GfQuath(q) /= s;
    }
 
  private:
    GfVec3h _imaginary;
 
    GfHalf _real;
 
    GfHalf
    _GetLengthSquared() const {
        return GfDot(*this, *this);
    }
};
 
GF_API GfQuath
GfSlerp(double alpha, const GfQuath& q0, const GfQuath& q1);
 
GF_API GfQuath
GfSlerp(const GfQuath& q0, const GfQuath& q1, double alpha);
 
inline GfHalf
GfDot(GfQuath const &q1, GfQuath const &q2) {
    return GfDot(q1.GetImaginary(), q2.GetImaginary()) +
                 q1.GetReal()*q2.GetReal();
}
 
GF_API std::ostream& operator<<(std::ostream &, GfQuath const &);
 
PXR_NAMESPACE_CLOSE_SCOPE
 
#endif // PXR_BASE_GF_QUATH_H