Quaternion

Imath.Quatf

class Imath.Quatf

float: None

V3f: None

Quatf() → Quatf

Quatf(Quatf) → Quatf

Quatf(Quatd) → Quatf

Quatf(float s, float i, float j, float k) → Quatf

Quatf(float s, V3f d) → Quatf

Quatf(float s, table[3] t) → Quatf

Quatf(table[4] t) → Quatf

operator==(Quatf q) const -> boolean

operator!=(Quatf q) const -> boolean

operator[](int idx) const -> float

operator[](int idx, float value)

operator*(M33f m) const -> M33f

operator*(Quatf q) const -> Quatf

operator*(float s) const -> Quatf

operator/(Quatf q) const -> Quatf

operator/(float s) const -> Quatf

operator+(Quatf q) const -> Quatf

operator-(Quatf q) const -> Quatf

operator-() const -> Quatf

operator^(Quatf q) const -> Quatf

not_() const -> Quatf

invert() → Quatf&

inverse() const -> Quatf

normalize() → Quatf&

normalized() const -> Quatf

length() const -> float

rotateVector(V3f original) const -> V3f

euclideanInnerProduct(Quatf q) const -> float

setAxisAngle(V3f axis, float radians) → Quatf&

setRotation(V3f fromDirection, V3f toDirection) → Quatf&

angle() const -> float

axis() const -> V3f

toMatrix33() const -> M33f

toMatrix44() const -> M44f

log() const -> Quatf

exp() const -> Quatf

toTable() const -> table[4]

static makeIdentity() → Quatf

static slerp(Quatf q1, Quatf q2, float t) → Quatf

static slerpShortestArc(Quatf q1, Quatf q2, float t) → Quatf

static squad(Quatf q1, Quatf q2, Quatf qa, Quatf qb, float t) → Quatf

static intermediate(Quatf q0, Quatf q1, Quatf q2) → Quatf

static intermediate(Quatf q0, Quatf q1, Quatf q2, Quatf q3, Quatf& qa, Quatf& qb)

static intermediate(Quatf q0, Quatf q1, Quatf q2, Quatf q3) → Quatf, Quatf

Imath.Quatd

class Imath.Quatd

double: None

V3d: None

Quatd() → Quatd

Quatd(Quatd) → Quatd

Quatd(Quatf) → Quatd

Quatd(double s, double i, double j, double k) → Quatd

Quatd(double s, V3d d) → Quatd

Quatd(double s, table[3] t) → Quatd

Quatd(table[4] t) → Quatd

operator==(Quatd q) const -> boolean

operator!=(Quatd q) const -> boolean

operator[](int idx) const -> double

operator[](int idx, double value)

operator*(M33d m) const -> M33d

operator*(Quatd q) const -> Quatd

operator*(double s) const -> Quatd

operator/(Quatd q) const -> Quatd

operator/(double s) const -> Quatd

operator+(Quatd q) const -> Quatd

operator-(Quatd q) const -> Quatd

operator-() const -> Quatd

operator^(Quatd q) const -> Quatd

not_() const -> Quatd

invert() → Quatd&

inverse() const -> Quatd

normalize() → Quatd&

normalized() const -> Quatd

length() const -> double

rotateVector(V3d original) const -> V3d

euclideanInnerProduct(Quatd q) const -> double

setAxisAngle(V3d axis, double radians) → Quatd&

setRotation(V3d fromDirection, V3d toDirection) → Quatd&

angle() const -> double

axis() const -> V3d

toMatrix33() const -> M33d

toMatrix44() const -> M44d

log() const -> Quatd

exp() const -> Quatd

toTable() const -> table[4]

static makeIdentity() → Quatd

static slerp(Quatd q1, Quatd q2, double t) → Quatd

static slerpShortestArc(Quatd q1, Quatd q2, double t) → Quatd

static squad(Quatd q1, Quatd q2, Quatd qa, Quatd qb, double t) → Quatd

static intermediate(Quatd q0, Quatd q1, Quatd q2) → Quatd

static intermediate(Quatd q0, Quatd q1, Quatd q2, Quatd q3, Quatd& qa, Quatd& qb)

static intermediate(Quatd q0, Quatd q1, Quatd q2, Quatd q3) → Quatd, Quatd