зеркало из https://github.com/mozilla/gecko-dev.git
103 строки
2.6 KiB
C++
103 строки
2.6 KiB
C++
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
|
|
/* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
|
|
|
|
#ifndef MOZILLA_GFX_QUATERNION_H_
|
|
#define MOZILLA_GFX_QUATERNION_H_
|
|
|
|
#include "Types.h"
|
|
#include <math.h>
|
|
#include <ostream>
|
|
#include "mozilla/Attributes.h"
|
|
#include "mozilla/DebugOnly.h"
|
|
#include "mozilla/gfx/MatrixFwd.h"
|
|
#include "mozilla/gfx/Point.h"
|
|
|
|
namespace mozilla {
|
|
namespace gfx {
|
|
|
|
class Quaternion {
|
|
public:
|
|
Quaternion() : x(0.0f), y(0.0f), z(0.0f), w(1.0f) {}
|
|
|
|
Quaternion(Float aX, Float aY, Float aZ, Float aW)
|
|
: x(aX), y(aY), z(aZ), w(aW) {}
|
|
|
|
Quaternion(const Quaternion& aOther) { memcpy(this, &aOther, sizeof(*this)); }
|
|
|
|
Float x, y, z, w;
|
|
|
|
friend std::ostream& operator<<(std::ostream& aStream,
|
|
const Quaternion& aQuat);
|
|
|
|
void Set(Float aX, Float aY, Float aZ, Float aW) {
|
|
x = aX;
|
|
y = aY;
|
|
z = aZ;
|
|
w = aW;
|
|
}
|
|
|
|
// Assumes upper 3x3 of aMatrix is a pure rotation matrix (no scaling)
|
|
void SetFromRotationMatrix(const Matrix4x4& aMatrix);
|
|
|
|
// result = this * aQuat
|
|
Quaternion operator*(const Quaternion& aQuat) const {
|
|
Quaternion o;
|
|
const Float bx = aQuat.x, by = aQuat.y, bz = aQuat.z, bw = aQuat.w;
|
|
|
|
o.x = x * bw + w * bx + y * bz - z * by;
|
|
o.y = y * bw + w * by + z * bx - x * bz;
|
|
o.z = z * bw + w * bz + x * by - y * bx;
|
|
o.w = w * bw - x * bx - y * by - z * bz;
|
|
return o;
|
|
}
|
|
|
|
Quaternion& operator*=(const Quaternion& aQuat) {
|
|
*this = *this * aQuat;
|
|
return *this;
|
|
}
|
|
|
|
Float Length() const { return sqrt(x * x + y * y + z * z + w * w); }
|
|
|
|
Quaternion& Conjugate() {
|
|
x *= -1.f;
|
|
y *= -1.f;
|
|
z *= -1.f;
|
|
return *this;
|
|
}
|
|
|
|
Quaternion& Normalize() {
|
|
Float l = Length();
|
|
if (l) {
|
|
l = 1.0f / l;
|
|
x *= l;
|
|
y *= l;
|
|
z *= l;
|
|
w *= l;
|
|
} else {
|
|
x = y = z = 0.f;
|
|
w = 1.f;
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
Quaternion& Invert() { return Conjugate().Normalize(); }
|
|
|
|
Point3D RotatePoint(const Point3D& aPoint) {
|
|
Float uvx = Float(2.0) * (y * aPoint.z - z * aPoint.y);
|
|
Float uvy = Float(2.0) * (z * aPoint.x - x * aPoint.z);
|
|
Float uvz = Float(2.0) * (x * aPoint.y - y * aPoint.x);
|
|
|
|
return Point3D(aPoint.x + w * uvx + y * uvz - z * uvy,
|
|
aPoint.y + w * uvy + z * uvx - x * uvz,
|
|
aPoint.z + w * uvz + x * uvy - y * uvx);
|
|
}
|
|
};
|
|
|
|
} // namespace gfx
|
|
} // namespace mozilla
|
|
|
|
#endif
|