dualQuatf.h

Go to the documentation of this file.

//
// Copyright 2021 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
// dualQuat.template.h file to make changes.
 
#ifndef PXR_BASE_GF_DUALQUATF_H
#define PXR_BASE_GF_DUALQUATF_H
 
 
#include "pxr/pxr.h"
#include "pxr/base/gf/api.h"
#include "pxr/base/gf/declare.h"
#include "pxr/base/gf/traits.h"
 
#include "pxr/base/gf/quatf.h"
#include "pxr/base/tf/hash.h"
 
#include <iosfwd>
 
PXR_NAMESPACE_OPEN_SCOPE
 
template <>
struct GfIsGfDualQuat<class GfDualQuatf> { static const bool value = true; };
 
float GfDot(const GfDualQuatf& dq1, const GfDualQuatf& dq2);
 
 
class GfDualQuatf final
{
  public:
    typedef float ScalarType;
 
    GfDualQuatf() {}
 
    explicit GfDualQuatf( float realVal ) : _real( realVal ), _dual( 0 ) {}
 
    explicit GfDualQuatf( const GfQuatf &real )
        : _real( real ), _dual( 0 ) {
    }
 
    GfDualQuatf( const GfQuatf &real, const GfQuatf &dual )
        : _real( real ), _dual( dual ) {
    }
 
    GfDualQuatf( const GfQuatf &rotation, const GfVec3f &translation )
        : _real( rotation ) {
        SetTranslation( translation );
    }
 
    GF_API
    explicit GfDualQuatf(const GfDualQuatd &other);
    GF_API
    GfDualQuatf(const GfDualQuath &other);
 
    void SetReal(const GfQuatf &real) {
        _real  = real;
    }
 
    void SetDual(const GfQuatf &dual) {
        _dual  = dual;
    }
 
    const GfQuatf &GetReal() const {
        return _real;
    }
 
    const GfQuatf &GetDual() const {
        return _dual;
    }
 
    static GfDualQuatf GetZero() {
        return GfDualQuatf(GfQuatf::GetZero(), GfQuatf::GetZero());
    }
 
    static GfDualQuatf GetIdentity() {
        return GfDualQuatf(GfQuatf::GetIdentity(), GfQuatf::GetZero());
    }
 
    GF_API
    std::pair<float, float> GetLength() const;
 
    GF_API
    GfDualQuatf GetNormalized(float eps = GF_MIN_VECTOR_LENGTH) const;
 
    GF_API
    std::pair<float, float> Normalize(float eps = GF_MIN_VECTOR_LENGTH);
 
    GF_API
    GfDualQuatf GetConjugate() const;
 
    GF_API
    GfDualQuatf GetInverse() const;
 
    GF_API
    void SetTranslation( const GfVec3f &translation );
 
    GF_API
    GfVec3f GetTranslation() const;
 
    friend inline size_t hash_value(const GfDualQuatf &dq) {
        return TfHash::Combine(dq.GetReal(), dq.GetDual());
    }
 
    bool operator ==(const GfDualQuatf &dq) const {
        return (GetReal() == dq.GetReal() &&
                GetDual() == dq.GetDual());
    }
 
    bool operator !=(const GfDualQuatf &dq) const {
        return ! (*this == dq);
    }
 
    GfDualQuatf &operator +=(const GfDualQuatf &dq)  {
        _real += dq._real;
        _dual += dq._dual;
        return *this;
    }
 
    GfDualQuatf &operator -=(const GfDualQuatf &dq)  {
        _real -= dq._real;
        _dual -= dq._dual;
        return *this;
    }
 
    GF_API
    GfDualQuatf &operator *=(const GfDualQuatf &dq);
 
    GfDualQuatf &operator *=(float s) {
        _real *= s;
        _dual *= s;
        return *this;
    }
 
    GfDualQuatf &operator /=(float s) {
        return (*this) *= 1.0 / s;
    }
 
    friend GfDualQuatf operator +(const GfDualQuatf &dq1,
                                     const GfDualQuatf &dq2) {
        GfDualQuatf dqt = dq1;
        return dqt += dq2;
    }
 
    friend GfDualQuatf operator -(const GfDualQuatf &dq1,
                                     const GfDualQuatf &dq2) {
        GfDualQuatf dqt = dq1;
        return dqt -= dq2;
    }
 
    friend GfDualQuatf operator *(const GfDualQuatf &dq1,
                                     const GfDualQuatf &dq2) {
        GfDualQuatf dqt  = dq1;
        return dqt *= dq2;
    }
 
    friend GfDualQuatf operator *(const GfDualQuatf &dq, float s) {
        GfDualQuatf dqt  = dq;
        return dqt *= s;
    }
 
    friend GfDualQuatf operator *(float s, const GfDualQuatf &dq) {
        GfDualQuatf dqt  = dq;
        return dqt *= s;
    }
 
    friend GfDualQuatf operator /(const GfDualQuatf &dq, float s) {
        GfDualQuatf dqt  = dq;
        return dqt /= s;
    }
 
    GF_API
    GfVec3f Transform(const GfVec3f &vec) const;
 
  private:
    GfQuatf _real;   // for rotation
    GfQuatf _dual;   // for translation
};
 
 
GF_API std::ostream &operator<<(std::ostream &out, const GfDualQuatf &dq);
 
 
inline float
GfDot(const GfDualQuatf& dq1, const GfDualQuatf& dq2) {
    return GfDot(dq1.GetReal(), dq2.GetReal()) + GfDot(dq1.GetDual(), dq2.GetDual());
}
 
PXR_NAMESPACE_CLOSE_SCOPE
 
#endif // PXR_BASE_GF_DUALQUATF_H