Struct Rotator

pub struct Rotator {
    pub pitch: f32,
    pub yaw: f32,
    pub roll: f32,
}

Unreal Engine style Rotator (Pitch, Yaw, Roll in degrees)

Represents rotation using Euler angles in degrees:

• Pitch: Rotation around Y axis (up/down)
• Yaw: Rotation around Z axis (left/right)
• Roll: Rotation around X axis (banking)

Fields

pitch: f32

Rotation around Y axis (degrees)

yaw: f32

Rotation around Z axis (degrees)

roll: f32

Rotation around X axis (degrees)

Implementations

impl Rotator

pub const ZERO: Self

Zero rotation constant

pub fn new(pitch: f32, yaw: f32, roll: f32) -> Self

Create a new rotator with the given pitch, yaw, and roll (in degrees)

pub fn from_yaw(yaw: f32) -> Self

Create a rotator with only yaw rotation

pub fn from_pitch(pitch: f32) -> Self

Create a rotator with only pitch rotation

pub fn from_roll(roll: f32) -> Self

Create a rotator with only roll rotation

pub fn to_quaternion(self) -> Quaternion

Convert to quaternion (preferred for math operations)

pub fn from_quaternion(quat: Quaternion) -> Self

Create from quaternion

pub fn normalize(self) -> Self

Normalize angles to [-180, 180] range

pub fn get_forward_vector(self) -> Vector

Get the forward vector for this rotation

pub fn get_right_vector(self) -> Vector

Get the right vector for this rotation

pub fn get_up_vector(self) -> Vector

Get the up vector for this rotation

pub fn is_nearly_zero(self, tolerance: f32) -> bool

Check if this rotator is nearly zero

pub fn is_nearly_equal(self, other: Rotator, tolerance: f32) -> bool

Check if two rotators are nearly equal

pub fn add(self, other: Rotator) -> Self

Add rotators component-wise

pub fn sub(self, other: Rotator) -> Self

Subtract rotators component-wise

pub fn scale(self, factor: f32) -> Self

Scale rotator by a factor

Trait Implementations

impl BinarySerializable for Rotator

fn to_binary(&self) -> Result<Vec<u8>, Error>

where Self: Serialize,

Serialize to binary format

fn from_binary(data: &[u8]) -> Result<Self, Error>

where Self: DeserializeOwned,

Deserialize from binary format

impl Clone for Rotator

fn clone(&self) -> Rotator

Returns a duplicate of the value.

const fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Rotator

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Rotator

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Rotator

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Rotator

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl PartialEq for Rotator

fn eq(&self, other: &Rotator) -> bool

Tests for self and other values to be equal, and is used by ==.

const fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Rotator

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Copy for Rotator

impl StructuralPartialEq for Rotator