Quaternion¶

More information can be found in the Unity API Reference and maybe in the Unity Manual.

Constructors¶

Constructor	Description
`Quaternion()`
`Quaternion(x, y, z, w)`

Members¶

Member	Description
`eulerAngles`
`normalized`
`w`
`x`
`y`
`z`

Methods¶

Method	Description
`GetHashCode()`
`Normalize()`
`Set(newX, newY, newZ, newW)`
`SetFromToRotation(fromDirection, toDirection)`
`SetLookRotation(view)`
`SetLookRotation(view, up)`
`ToAngleAxis(angle, axis)`
`ToString()`
`ToString(format)`

Static members¶

Member	Description
`identity`
`kEpsilon`

Static methods¶

Method	Description
`Angle(a, b)`
`AngleAxis(angle, axis)`
`Dot(a, b)`
`Euler(euler)`
`Euler(x, y, z)`
`FromToRotation(fromDirection, toDirection)`
`Inverse(rotation)`
`Lerp(a, b, t)`
`LerpUnclamped(a, b, t)`
`LookRotation(forward)`
`LookRotation(forward, upwards)`
`Normalize(q)`
`RotateTowards(from, to, maxDegreesDelta)`
`Slerp(a, b, t)`
`SlerpUnclamped(a, b, t)`

Operators¶

Operator	Description
`operator !=(lhs, rhs)`
`operator *(lhs, rhs)`
`operator *(rotation, point)`
`operator ==(lhs, rhs)`

Details¶

class Quaternion¶

Quaternion Quaternion(float x, float y, float z, float w)¶

Quaternion Quaternion()¶

Vector3 eulerAngles¶

const Quaternion normalized¶

float w¶

float x¶

float y¶

float z¶

int GetHashCode()¶

void Normalize()¶

void Set(float newX, float newY, float newZ, float newW)¶

void SetFromToRotation(Vector3 fromDirection, Vector3 toDirection)¶

void SetLookRotation(Vector3 view)¶

void SetLookRotation(Vector3 view, Vector3 up)¶

void ToAngleAxis(float angle, Vector3 axis)¶

string ToString()¶

string ToString(string format)¶

static const Quaternion identity

static const float kEpsilon¶

static float Angle(Quaternion a, Quaternion b)¶

static Quaternion AngleAxis(float angle, Vector3 axis)¶

static float Dot(Quaternion a, Quaternion b)¶

static Quaternion Euler(Vector3 euler)¶

static Quaternion Euler(float x, float y, float z)¶

static Quaternion FromToRotation(Vector3 fromDirection, Vector3 toDirection)¶

static Quaternion Inverse(Quaternion rotation)¶

static Quaternion Lerp(Quaternion a, Quaternion b, float t)¶

static Quaternion LerpUnclamped(Quaternion a, Quaternion b, float t)¶

static Quaternion LookRotation(Vector3 forward)¶

static Quaternion LookRotation(Vector3 forward, Vector3 upwards)¶

static Quaternion Normalize(Quaternion q)¶

static Quaternion RotateTowards(Quaternion from, Quaternion to, float maxDegreesDelta)¶

static Quaternion Slerp(Quaternion a, Quaternion b, float t)¶

static Quaternion SlerpUnclamped(Quaternion a, Quaternion b, float t)¶

static bool operator!=(Quaternion lhs, Quaternion rhs)¶

static Quaternion operator*(Quaternion lhs, Quaternion rhs)¶

static Vector3 operator*(Quaternion rotation, Vector3 point)¶

static bool operator==(Quaternion lhs, Quaternion rhs)¶