quatf.h

Go to the documentation of this file.

//
// Copyright 2016 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
// quat.template.h file to make changes.

#ifndef PXR_BASE_GF_QUATF_H
#define PXR_BASE_GF_QUATF_H


#include "pxr/pxr.h"
#include "pxr/base/gf/api.h"
#include "pxr/base/gf/declare.h"
#include "pxr/base/gf/vec3f.h"
#include "pxr/base/gf/traits.h"

#include <boost/functional/hash.hpp>

#include <iosfwd>

PXR_NAMESPACE_OPEN_SCOPE

template <>
struct GfIsGfQuat<class GfQuatf> { static const bool value = true; };


float GfDot(const GfQuatf& q1, const GfQuatf& q2);


class GfQuatf
{
  public:
    typedef float ScalarType;
    typedef GfVec3f ImaginaryType;

    GfQuatf() {}

    explicit GfQuatf (float realVal) : _imaginary(0), _real(realVal) {}

    GfQuatf(float real, float i, float j, float k)
        : _imaginary(i, j, k), _real(real)
    {
    }

    GfQuatf(float real, const GfVec3f &imaginary)
        : _imaginary(imaginary), _real(real)
    {
    }

    GF_API
    explicit GfQuatf(class GfQuatd const &other);
    GF_API
    GfQuatf(class GfQuath const &other);

    static GfQuatf GetZero() { return GfQuatf(0.0); }

    static GfQuatf GetIdentity() { return GfQuatf(1.0); }

    float GetReal() const { return _real; }

    void SetReal(float real) { _real = real; }

    const GfVec3f &GetImaginary() const { return _imaginary; }

    void SetImaginary(const GfVec3f &imaginary) {
        _imaginary = imaginary;
    }

    void SetImaginary(float i, float j, float k) {
        _imaginary.Set(i, j, k);
    }

    float GetLength() const { return GfSqrt(_GetLengthSquared()); }

    GfQuatf
    GetNormalized(float eps = GF_MIN_VECTOR_LENGTH) const {
        GfQuatf ret(*this);
        ret.Normalize(eps);
        return ret;
    }

    GF_API
    float Normalize(float eps = GF_MIN_VECTOR_LENGTH);

    GfQuatf GetConjugate() const {
        return GfQuatf(GetReal(), -GetImaginary());
    }

    GfQuatf GetInverse() const {
        return GetConjugate() / _GetLengthSquared();
    }

    GF_API
    GfVec3f Transform(const GfVec3f& point) const;

    friend inline size_t hash_value(const GfQuatf &q) {
        size_t h = boost::hash<ScalarType>()(q.GetReal());
        boost::hash_combine(h, q.GetImaginary());
        return h;
    }

    GfQuatf operator-() const {
        return GfQuatf(-GetReal(), -GetImaginary());
    }

    bool operator==(const GfQuatf &q) const {
        return (GetReal() == q.GetReal() &&
                GetImaginary() == q.GetImaginary());
    }

    bool operator!=(const GfQuatf &q) const {
        return !(*this == q);
    }

    GF_API
    GfQuatf &operator *=(const GfQuatf &q);

    GfQuatf &operator *=(float s) {
        _real *= s;
        _imaginary *= s;
        return *this;
    }

    GfQuatf &operator /=(float s) {
        _real /= s;
        _imaginary /= s;
        return *this;
    }

    GfQuatf &operator +=(const GfQuatf &q) {
        _real += q._real;
        _imaginary += q._imaginary;
        return *this;
    }

    GfQuatf &operator -=(const GfQuatf &q)  {
        _real -= q._real;
        _imaginary -= q._imaginary;
        return *this;
    }

    friend GfQuatf
    operator +(const GfQuatf &q1, const GfQuatf &q2) {
        return GfQuatf(q1) += q2;
    }

    friend GfQuatf
    operator -(const GfQuatf &q1, const GfQuatf &q2) {
        return GfQuatf(q1) -= q2;
    }

    friend GfQuatf
    operator *(const GfQuatf &q1, const GfQuatf &q2) {
        return GfQuatf(q1) *= q2;
    }

    friend GfQuatf
    operator *(const GfQuatf &q, float s) {
        return GfQuatf(q) *= s;
    }

    friend GfQuatf
    operator *(float s, const GfQuatf &q) {
        return GfQuatf(q) *= s;
    }

    friend GfQuatf
    operator /(const GfQuatf &q, float s) {
        return GfQuatf(q) /= s;
    }

  private:
    GfVec3f _imaginary;

    float _real;

    float
    _GetLengthSquared() const {
        return GfDot(*this, *this);
    }
};

GF_API GfQuatf
GfSlerp(double alpha, const GfQuatf& q0, const GfQuatf& q1);

GF_API GfQuatf
GfSlerp(const GfQuatf& q0, const GfQuatf& q1, double alpha);

inline float
GfDot(GfQuatf const &q1, GfQuatf const &q2) {
    return GfDot(q1.GetImaginary(), q2.GetImaginary()) +
                 q1.GetReal()*q2.GetReal();
}

GF_API std::ostream& operator<<(std::ostream &, GfQuatf const &);

PXR_NAMESPACE_CLOSE_SCOPE

#endif // PXR_BASE_GF_QUATF_H