Struct veloren_common::comp::ori::Ori

pub struct Ori(Quaternion<f32>);

Tuple Fields

0: Quaternion<f32>

Implementations

impl Ori

pub fn new(quat: Quaternion<f32>) -> Self

pub fn from_unnormalized_vec<T>(vec: T) -> Option<Self>

where T: Into<Vec3<f32>>,

Tries to convert into a Dir and then the appropriate rotation

pub fn look_vec(self) -> Vec3<f32>

Look direction as a vector (no pedantic normalization performed)

pub fn to_quat(self) -> Quaternion<f32>

Get the internal quaternion representing the rotation from Dir::default() to this orientation.

The operation is a cheap copy.

pub fn look_dir(&self) -> Dir

Look direction (as a Dir it is pedantically normalized)

pub fn up(&self) -> Dir

pub fn down(&self) -> Dir

pub fn left(&self) -> Dir

pub fn right(&self) -> Dir

pub fn slerp(ori1: Self, ori2: Self, s: f32) -> Self

pub fn slerped_towards(self, ori: Ori, s: f32) -> Self

pub fn rotated(self, q: Quaternion<f32>) -> Self

Multiply rotation quaternion by q (the rotations are in local vector space).

use vek::{Quaternion, Vec3};
use veloren_common::{comp::Ori, util::Dir};

let ang = 90_f32.to_radians();
let roll_right = Quaternion::rotation_y(ang);
let pitch_up = Quaternion::rotation_x(ang);

let ori1 = Ori::from(Dir::new(Vec3::unit_x()));
let ori2 = Ori::default().rotated(roll_right).rotated(pitch_up);

assert!((ori1.look_dir().dot(*ori2.look_dir()) - 1.0).abs() <= f32::EPSILON);

pub fn prerotated(self, q: Quaternion<f32>) -> Self

Premultiply rotation quaternion by q (the rotations are in global vector space).

use vek::{Quaternion, Vec3};
use veloren_common::{comp::Ori, util::Dir};

let ang = 90_f32.to_radians();
let roll_right = Quaternion::rotation_y(ang);
let pitch_up = Quaternion::rotation_x(ang);

let ori1 = Ori::from(Dir::up());
let ori2 = Ori::default().prerotated(roll_right).prerotated(pitch_up);

assert!((ori1.look_dir().dot(*ori2.look_dir()) - 1.0).abs() <= f32::EPSILON);

pub fn global_to_local<T>( &self, global: T, ) -> <Quaternion<f32> as Mul<T>>::Output

where Quaternion<f32>: Mul<T>,

Take global into this Ori’s local vector space

use vek::Vec3;
use veloren_common::{comp::Ori, util::Dir};

let ang = 90_f32.to_radians();
let (fw, left, up) = (Dir::default(), Dir::left(), Dir::up());

let ori = Ori::default().rolled_left(ang).pitched_up(ang);
approx::assert_relative_eq!(ori.global_to_local(fw).dot(*-up), 1.0);
approx::assert_relative_eq!(ori.global_to_local(left).dot(*fw), 1.0);
let ori = Ori::default().rolled_right(ang).pitched_up(2.0 * ang);
approx::assert_relative_eq!(ori.global_to_local(up).dot(*left), 1.0);

pub fn local_to_global<T>( &self, local: T, ) -> <Quaternion<f32> as Mul<T>>::Output

where Quaternion<f32>: Mul<T>,

Take local into the global vector space

use vek::Vec3;
use veloren_common::{comp::Ori, util::Dir};

let ang = 90_f32.to_radians();
let (fw, left, up) = (Dir::default(), Dir::left(), Dir::up());

let ori = Ori::default().rolled_left(ang).pitched_up(ang);
approx::assert_relative_eq!(ori.local_to_global(fw).dot(*left), 1.0);
approx::assert_relative_eq!(ori.local_to_global(left).dot(*-up), 1.0);
let ori = Ori::default().rolled_right(ang).pitched_up(2.0 * ang);
approx::assert_relative_eq!(ori.local_to_global(up).dot(*left), 1.0);

pub fn to_horizontal(self) -> Self

pub fn angle_between(self, other: Self) -> f32

Find the angle between two Oris

NOTE: This finds the angle of the quaternion between the two Oris which can involve rolling and thus can be larger than simply the angle between vectors at the start and end points.

Returns angle in radians

pub fn dot(self, other: Self) -> f32

pub fn pitched_up(self, angle_radians: f32) -> Self

pub fn pitched_down(self, angle_radians: f32) -> Self

pub fn yawed_left(self, angle_radians: f32) -> Self

pub fn yawed_right(self, angle_radians: f32) -> Self

pub fn rolled_left(self, angle_radians: f32) -> Self

pub fn rolled_right(self, angle_radians: f32) -> Self

pub fn rolled_towards(self, dir: Dir) -> Self

Returns a version which is rolled such that its up points towards dir as much as possible without pitching or yawing

pub fn pitched_towards(self, dir: Dir) -> Self

Returns a version which has been pitched towards dir as much as possible without yawing or rolling

pub fn yawed_towards(self, dir: Dir) -> Self

Returns a version which has been yawed towards dir as much as possible without pitching or rolling

pub fn uprighted(self) -> Self

Returns a version without sideways tilt (roll)

use veloren_common::comp::Ori;

let ang = 45_f32.to_radians();
let zenith = vek::Vec3::unit_z();

let rl = Ori::default().rolled_left(ang);
assert!((rl.up().angle_between(zenith) - ang).abs() <= f32::EPSILON);
assert!(rl.uprighted().up().angle_between(zenith) <= f32::EPSILON);

let pd_rr = Ori::default().pitched_down(ang).rolled_right(ang);
let pd_upr = pd_rr.uprighted();

assert!((pd_upr.up().angle_between(zenith) - ang).abs() <= f32::EPSILON);

let ang1 = pd_upr.rolled_right(ang).up().angle_between(zenith);
let ang2 = pd_rr.up().angle_between(zenith);
assert!((ang1 - ang2).abs() <= f32::EPSILON);

fn is_normalized(&self) -> bool

Trait Implementations

impl Clone for Ori

fn clone(&self) -> Ori

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Component for Ori

type Storage = VecStorage<Ori>

Associated storage type for this component.

impl Debug for Ori

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

Formats the value using the given formatter.

impl Default for Ori

fn default() -> Self

Returns the default orientation (no rotation; default Dir)

impl<'de> Deserialize<'de> for Ori

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<Dir> for Ori

fn from(dir: Dir) -> Self

Converts to this type from the input type.

impl From<Ori> for Dir

fn from(ori: Ori) -> Self

Converts to this type from the input type.

impl From<Ori> for Quaternion<f32>

fn from(Ori: Ori) -> Self

Converts to this type from the input type.

impl From<Ori> for Quaternion<f32>

fn from(Ori: Ori) -> Self

Converts to this type from the input type.

impl From<Ori> for SerdeOri

fn from(other: Ori) -> SerdeOri

Converts to this type from the input type.

impl From<Ori> for Vec2<f32>

fn from(ori: Ori) -> Self

Converts to this type from the input type.

impl From<Ori> for Vec2<f32>

fn from(ori: Ori) -> Self

Converts to this type from the input type.

impl From<Ori> for Vec3<f32>

fn from(ori: Ori) -> Self

Converts to this type from the input type.

impl From<Ori> for Vec3<f32>

fn from(ori: Ori) -> Self

Converts to this type from the input type.

impl From<Quaternion<f32>> for Ori

fn from(_: Quaternion<f32>) -> Self

Converts to this type from the input type.

impl From<Quaternion<f32>> for Ori

fn from(quat: Quaternion<f32>) -> Self

Converts to this type from the input type.

impl From<SerdeOri> for Ori

fn from(serde_quat: SerdeOri) -> Self

Converts to this type from the input type.

impl From<Vec3<f32>> for Ori

fn from(dir: Vec3<f32>) -> Self

Converts to this type from the input type.

impl PartialEq for Ori

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl Serialize for Ori

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 Ori

impl StructuralPartialEq for Ori