dualQuath.h

Go to the documentation of this file.

//
// Copyright 2021 Pixar
//
// Licensed under the Apache License, Version 2.0 (the "Apache License")
// with the following modification; you may not use this file except in
// compliance with the Apache License and the following modification to it:
// Section 6. Trademarks. is deleted and replaced with:
//
// 6. Trademarks. This License does not grant permission to use the trade
//    names, trademarks, service marks, or product names of the Licensor
//    and its affiliates, except as required to comply with Section 4(c) of
//    the License and to reproduce the content of the NOTICE file.
//
// You may obtain a copy of the Apache License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the Apache License with the above modification is
// distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied. See the Apache License for the specific
// language governing permissions and limitations under the Apache 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_DUALQUATH_H
#define PXR_BASE_GF_DUALQUATH_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/half.h"

#include "pxr/base/gf/quath.h"

#include <boost/functional/hash.hpp>

#include <iosfwd>

PXR_NAMESPACE_OPEN_SCOPE

template <>
struct GfIsGfDualQuat<class GfDualQuath> { static const bool value = true; };

GfHalf GfDot(const GfDualQuath& dq1, const GfDualQuath& dq2);


class GfDualQuath final
{
  public:
    typedef GfHalf ScalarType;

    GfDualQuath() {}

    explicit GfDualQuath( GfHalf realVal ) : _real( realVal ), _dual( 0 ) {}

    explicit GfDualQuath( const GfQuath &real )
        : _real( real ), _dual( 0 ) {
    }

    GfDualQuath( const GfQuath &real, const GfQuath &dual )
        : _real( real ), _dual( dual ) {
    }

    GfDualQuath( const GfQuath &rotation, const GfVec3h &translation )
        : _real( rotation ) {
        SetTranslation( translation );
    }

    GF_API
    explicit GfDualQuath(const GfDualQuatd &other);
    GF_API
    explicit GfDualQuath(const GfDualQuatf &other);

    void SetReal(const GfQuath &real) {
        _real  = real;
    }

    void SetDual(const GfQuath &dual) {
        _dual  = dual;
    }

    const GfQuath &GetReal() const {
        return _real;
    }

    const GfQuath &GetDual() const {
        return _dual;
    }

    static GfDualQuath GetZero() {
        return GfDualQuath(GfQuath::GetZero(), GfQuath::GetZero());
    }

    static GfDualQuath GetIdentity() {
        return GfDualQuath(GfQuath::GetIdentity(), GfQuath::GetZero());
    }

    GF_API
    std::pair<GfHalf, GfHalf> GetLength() const;

    GF_API
    GfDualQuath GetNormalized(GfHalf eps = GF_MIN_VECTOR_LENGTH) const;

    GF_API
    std::pair<GfHalf, GfHalf> Normalize(GfHalf eps = GF_MIN_VECTOR_LENGTH);

    GF_API
    GfDualQuath GetConjugate() const;

    GF_API
    GfDualQuath GetInverse() const;

    GF_API
    void SetTranslation( const GfVec3h &translation );

    GF_API
    GfVec3h GetTranslation() const;

    friend inline size_t hash_value(const GfDualQuath &dq) {
        size_t h = 0;
        boost::hash_combine(h, dq.GetReal());
        boost::hash_combine(h, dq.GetDual());
        return h;
    }

    bool operator ==(const GfDualQuath &dq) const {
        return (GetReal() == dq.GetReal() &&
                GetDual() == dq.GetDual());
    }

    bool operator !=(const GfDualQuath &dq) const {
        return ! (*this == dq);
    }

    GfDualQuath &operator +=(const GfDualQuath &dq)  {
        _real += dq._real;
        _dual += dq._dual;
        return *this;
    }

    GfDualQuath &operator -=(const GfDualQuath &dq)  {
        _real -= dq._real;
        _dual -= dq._dual;
        return *this;
    }

    GF_API
    GfDualQuath &operator *=(const GfDualQuath &dq);

    GfDualQuath &operator *=(GfHalf s) {
        _real *= s;
        _dual *= s;
        return *this;
    }

    GfDualQuath &operator /=(GfHalf s) {
        return (*this) *= 1.0 / s;
    }

    friend GfDualQuath operator +(const GfDualQuath &dq1,
                                     const GfDualQuath &dq2) {
        GfDualQuath dqt = dq1;
        return dqt += dq2;
    }

    friend GfDualQuath operator -(const GfDualQuath &dq1,
                                     const GfDualQuath &dq2) {
        GfDualQuath dqt = dq1;
        return dqt -= dq2;
    }

    friend GfDualQuath operator *(const GfDualQuath &dq1,
                                     const GfDualQuath &dq2) {
        GfDualQuath dqt  = dq1;
        return dqt *= dq2;
    }

    friend GfDualQuath operator *(const GfDualQuath &dq, GfHalf s) {
        GfDualQuath dqt  = dq;
        return dqt *= s;
    }

    friend GfDualQuath operator *(GfHalf s, const GfDualQuath &dq) {
        GfDualQuath dqt  = dq;
        return dqt *= s;
    }

    friend GfDualQuath operator /(const GfDualQuath &dq, GfHalf s) {
        GfDualQuath dqt  = dq;
        return dqt /= s;
    }

    GF_API
    GfVec3h Transform(const GfVec3h &vec) const;

  private:
    GfQuath _real;   // for rotation
    GfQuath _dual;   // for translation
};


GF_API std::ostream &operator<<(std::ostream &out, const GfDualQuath &dq);


inline GfHalf
GfDot(const GfDualQuath& dq1, const GfDualQuath& dq2) {
    return GfDot(dq1.GetReal(), dq2.GetReal()) + GfDot(dq1.GetDual(), dq2.GetDual());
}

PXR_NAMESPACE_CLOSE_SCOPE

#endif // PXR_BASE_GF_DUALQUATH_H