Glam

https://docs.rs/glam/latest/glam
Admin
Glam is a simple and fast linear algebra library for games and graphics, providing SIMD-optimized...
Tokens:197,505
Snippets:1,801
Trust Score:9.7
Update:3 months ago
Show doc for...
Tokens:
Raw
### With Methods

Source: https://docs.rs/glam/latest/glam/u16/struct.U16Vec4.html

Methods to update specific component combinations within a U16Vec4 instance.

```APIDOC
## With Methods

### Description
These methods return a new U16Vec4 with specific components replaced by the provided vector, while keeping other components from the original instance.

### Methods
- **fn with_[component_combination](self, rhs: [VectorType]) -> Self**

### Parameters
- **self** - The original U16Vec4 instance.
- **rhs** - The vector containing the new values to be inserted.

### Returns
- **Self** - A new U16Vec4 instance with the updated components.
```

--------------------------------

### TryFrom<USizeVec3> for I64Vec3

Source: https://docs.rs/glam/latest/glam/usize/struct.USizeVec3.html?search=std%3A%3Avec

Converts a USizeVec3 to an I64Vec3. Requires the 'usize' crate feature.

```APIDOC
## fn try_from(v: USizeVec3) -> Result<I64Vec3, TryFromIntError>

### Description
Performs the conversion from USizeVec3 to I64Vec3.

### Parameters
- **v** (USizeVec3) - The vector to convert.

### Returns
- **Result<I64Vec3, TryFromIntError>** - The converted vector or a conversion error.
```

--------------------------------

### TryFrom<USizeVec3> for U64Vec3

Source: https://docs.rs/glam/latest/glam/usize/struct.USizeVec3.html?search=std%3A%3Avec

Converts a USizeVec3 to a U64Vec3. Requires the 'usize' crate feature.

```APIDOC
## fn try_from(v: USizeVec3) -> Result<U64Vec3, TryFromIntError>

### Description
Performs the conversion from USizeVec3 to U64Vec3.

### Parameters
- **v** (USizeVec3) - The vector to convert.

### Returns
- **Result<U64Vec3, TryFromIntError>** - The converted vector or a conversion error.
```

--------------------------------

### TryFrom<U64Vec3> for ISizeVec3

Source: https://docs.rs/glam/latest/glam/isize/struct.ISizeVec3.html?search=

Converts a U64Vec3 to an ISizeVec3. Requires the 'u64' crate feature.

```APIDOC
## fn try_from(v: U64Vec3) -> Result<ISizeVec3, TryFromIntError>

### Description
Performs a fallible conversion from a U64Vec3 to an ISizeVec3.

### Parameters
- **v** (U64Vec3) - The source vector to convert.

### Returns
- **Result<ISizeVec3, TryFromIntError>** - Returns the converted ISizeVec3 on success, or a TryFromIntError if the conversion fails.
```

--------------------------------

### i16 Vector Functions

Source: https://docs.rs/glam/latest/glam/i16/index.html

Constructor functions for creating i16 vector instances.

```APIDOC
## Functions

- **i16vec2(x, y)**: Creates a 2-dimensional vector.
- **i16vec3(x, y, z)**: Creates a 3-dimensional vector.
- **i16vec4(x, y, z, w)**: Creates a 4-dimensional vector.
```

--------------------------------

### TryFrom<UVec3> for USizeVec3

Source: https://docs.rs/glam/latest/glam/usize/struct.USizeVec3.html?search=std%3A%3Avec

Converts a UVec3 to a USizeVec3. Requires the 'u32' crate feature.

```APIDOC
## fn try_from(v: UVec3) -> Result<USizeVec3, TryFromIntError>

### Description
Performs the conversion from UVec3 to USizeVec3.

### Parameters
- **v** (UVec3) - The vector to convert.

### Returns
- **Result<USizeVec3, TryFromIntError>** - The converted vector or a conversion error.
```

--------------------------------

### Quat Constructors

Source: https://docs.rs/glam/latest/glam/f32/struct.Quat.html?search=u32+-%3E+bool

Methods for creating a new Quat instance from various inputs like arrays, vectors, slices, or rotation definitions.

```APIDOC
## Constructors

- `from_xyzw(x: f32, y: f32, z: f32, w: f32) -> Self`: Creates a new rotation quaternion.
- `from_array(a: [f32; 4]) -> Self`: Creates a rotation quaternion from an array.
- `from_vec4(v: Vec4) -> Self`: Creates a new rotation quaternion from a 4D vector.
- `from_slice(slice: &[f32]) -> Self`: Creates a rotation quaternion from a slice (panics if length < 4).
- `from_axis_angle(axis: Vec3, angle: f32) -> Self`: Creates a quaternion for a normalized rotation axis and angle.
- `from_scaled_axis(v: Vec3) -> Self`: Creates a quaternion that rotates v.length() radians around v.normalize().
- `from_rotation_x(angle: f32) -> Self`: Creates a quaternion from the angle around the x axis.
- `from_rotation_y(angle: f32) -> Self`: Creates a quaternion from the angle around the y axis.
- `from_rotation_z(angle: f32) -> Self`: Creates a quaternion from the angle around the z axis.
- `from_euler(euler: EulerRot, a: f32, b: f32, c: f32) -> Self`: Creates a quaternion from Euler rotation sequence and angles.
- `from_rotation_axes(x_axis: Vec3, y_axis: Vec3, z_axis: Vec3) -> Self`: Creates a quaternion from the columns of a 3x3 rotation matrix.
- `from_mat3(mat: &Mat3) -> Self`: Creates a quaternion from a 3x3 rotation matrix.
- `from_mat3a(mat: &Mat3A) -> Self`: Creates a quaternion from a 3x3 SIMD aligned rotation matrix.
- `from_mat4(mat: &Mat4) -> Self`: Creates a quaternion from the upper 3x3 rotation matrix of a 4x4 matrix.
```

--------------------------------

### Create a 3D vector with ivec3

Source: https://docs.rs/glam/latest/glam/i32/fn.ivec3.html

Initializes a new IVec3 instance using three i32 values.

```rust
pub const fn ivec3(x: i32, y: i32, z: i32) -> IVec3
```

--------------------------------

### Calculate Euler Rotations

Source: https://docs.rs/glam/latest/glam/enum.EulerRot.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates how to use EulerRot variants to create rotation matrices for intrinsic and extrinsic sequences.

```rust
let m_intrinsic = Mat3::from_rotation_x(i) * Mat3::from_rotation_y(j) * Mat3::from_rotation_z(k);
let n_intrinsic = Mat3::from_euler(EulerRot::XYZ, i, j, k);
assert!(m_intrinsic.abs_diff_eq(n_intrinsic, 2e-6));

let m_extrinsic = Mat3::from_rotation_z(k) * Mat3::from_rotation_y(j) * Mat3::from_rotation_x(i);
let n_extrinsic = Mat3::from_euler(EulerRot::XYZEx, i, j, k);
assert!(m_extrinsic.abs_diff_eq(n_extrinsic, 2e-6));
```

--------------------------------

### fn xyzw(self) -> Self

Source: https://docs.rs/glam/latest/glam/u16/struct.U16Vec4.html?search=std%3A%3Avec

Returns a new instance of U16Vec4 with components mapped to the xyzw order.

```APIDOC
## fn xyzw(self) -> Self

### Description
Returns a new instance of U16Vec4 with components mapped to the xyzw order.

### Signature
`fn xyzw(self) -> Self`
```

--------------------------------

### u16 Vector Functions

Source: https://docs.rs/glam/latest/glam/u16/index.html

Constructor functions for creating u16 vector instances.

```APIDOC
## Functions

- **u16vec2**: Creates a 2-dimensional vector.
- **u16vec3**: Creates a 3-dimensional vector.
- **u16vec4**: Creates a 4-dimensional vector.
```

--------------------------------

### TryFrom Conversions

Source: https://docs.rs/glam/latest/glam/i64/struct.I64Vec4.html

Methods to convert other vector types into I64Vec4.

```APIDOC
## try_from(v: U64Vec4) -> Result<Self, Self::Error>

### Description
Converts a U64Vec4 into an I64Vec4. Requires the `u64` crate feature.

## try_from(v: USizeVec4) -> Result<Self, Self::Error>

### Description
Converts a USizeVec4 into an I64Vec4. Requires the `usize` crate feature.
```

--------------------------------

### TryFrom Conversions

Source: https://docs.rs/glam/latest/glam/i16/struct.I16Vec4.html

Methods to convert other vector types into I16Vec4, subject to crate feature availability.

```APIDOC
## TryFrom<USizeVec4> for I16Vec4

### Description
Converts a USizeVec4 to an I16Vec4. Requires the `usize` crate feature.

## TryFrom<UVec4> for I16Vec4

### Description
Converts a UVec4 to an I16Vec4. Requires the `u32` crate feature.
```

--------------------------------

### TryFrom<UVec3> for ISizeVec3

Source: https://docs.rs/glam/latest/glam/isize/struct.ISizeVec3.html?search=

Converts a UVec3 to an ISizeVec3. Requires the 'u32' crate feature.

```APIDOC
## fn try_from(v: UVec3) -> Result<ISizeVec3, TryFromIntError>

### Description
Performs a fallible conversion from a UVec3 to an ISizeVec3.

### Parameters
- **v** (UVec3) - The source vector to convert.

### Returns
- **Result<ISizeVec3, TryFromIntError>** - Returns the converted ISizeVec3 on success, or a TryFromIntError if the conversion fails.
```

--------------------------------

### Create a 3-dimensional vector

Source: https://docs.rs/glam/latest/glam/usize/fn.usizevec3.html

Initializes a USizeVec3 instance with the provided x, y, and z coordinates.

```rust
pub const fn usizevec3(x: usize, y: usize, z: usize) -> USizeVec3
```

--------------------------------

### fn wwww(self) -> Self

Source: https://docs.rs/glam/latest/glam/u16/struct.U16Vec4.html?search=std%3A%3Avec

Returns a new instance of U16Vec4 with components set to the w component of the original instance.

```APIDOC
## fn wwww(self) -> Self

### Description
Returns a new instance of U16Vec4 with all components set to the value of the w component of the original instance.

### Signature
`fn wwww(self) -> Self`
```

--------------------------------

### TryFrom<USizeVec3> for ISizeVec3

Source: https://docs.rs/glam/latest/glam/isize/struct.ISizeVec3.html?search=

Converts a USizeVec3 to an ISizeVec3. Requires the 'usize' crate feature.

```APIDOC
## fn try_from(v: USizeVec3) -> Result<ISizeVec3, TryFromIntError>

### Description
Performs a fallible conversion from a USizeVec3 to an ISizeVec3.

### Parameters
- **v** (USizeVec3) - The source vector to convert.

### Returns
- **Result<ISizeVec3, TryFromIntError>** - Returns the converted ISizeVec3 on success, or a TryFromIntError if the conversion fails.
```

--------------------------------

### TryFrom<U16Vec3> for ISizeVec3

Source: https://docs.rs/glam/latest/glam/isize/struct.ISizeVec3.html?search=

Converts a U16Vec3 to an ISizeVec3. Requires the 'u16' crate feature.

```APIDOC
## fn try_from(v: U16Vec3) -> Result<ISizeVec3, TryFromIntError>

### Description
Performs a fallible conversion from a U16Vec3 to an ISizeVec3.

### Parameters
- **v** (U16Vec3) - The source vector to convert.

### Returns
- **Result<ISizeVec3, TryFromIntError>** - Returns the converted ISizeVec3 on success, or a TryFromIntError if the conversion fails.
```

--------------------------------

### Create a 3-dimensional vector

Source: https://docs.rs/glam/latest/glam/u64/fn.u64vec3.html

Initializes a new U64Vec3 instance using three u64 values.

```rust
pub const fn u64vec3(x: u64, y: u64, z: u64) -> U64Vec3
```

--------------------------------

### Vector Creation Functions

Source: https://docs.rs/glam/latest/glam/u32/index.html?search=std%3A%3Avec

Functions used to instantiate unsigned integer vectors.

```APIDOC
## uvec2(x: u32, y: u32) -> UVec2
Creates a 2-dimensional vector.

## uvec3(x: u32, y: u32, z: u32) -> UVec3
Creates a 3-dimensional vector.

## uvec4(x: u32, y: u32, z: u32, w: u32) -> UVec4
Creates a 4-dimensional vector.
```

--------------------------------

### TryFrom Conversions

Source: https://docs.rs/glam/latest/glam/u16/struct.U16Vec4.html?search=u32+-%3E+bool

Implementations for converting various vector types into U16Vec4.

```APIDOC
## TryFrom Conversions

- `TryFrom<ISizeVec4> for U16Vec4` (requires `u16` feature)
- `TryFrom<U64Vec4> for U16Vec4` (requires `u64` feature)
- `TryFrom<USizeVec4> for U16Vec4` (requires `usize` feature)
- `TryFrom<UVec4> for U16Vec4` (requires `u32` feature)

Each implementation returns a `Result<Self, TryFromIntError>`.
```

--------------------------------

### Create a 2D vector with uvec2

Source: https://docs.rs/glam/latest/glam/u32/fn.uvec2.html

Initializes a new UVec2 instance using two u32 values.

```rust
pub const fn uvec2(x: u32, y: u32) -> UVec2
```

--------------------------------

### Create a 2x2 matrix using mat2

Source: https://docs.rs/glam/latest/glam/f32/fn.mat2.html

Constructs a Mat2 instance by providing two Vec2 column vectors.

```rust
pub const fn mat2(x_axis: Vec2, y_axis: Vec2) -> Mat2
```

--------------------------------

### as_daffine3

Source: https://docs.rs/glam/latest/glam/f32/struct.Affine3.html

Casts the matrix elements to f64.

```APIDOC
## pub fn as_daffine3(&self) -> DAffine3

### Description
Casts all elements of `self` to `f64`.
```

--------------------------------

### Create a 3D vector

Source: https://docs.rs/glam/latest/glam/f32/fn.vec3.html?search=

Initializes a new Vec3 instance using three f32 values.

```rust
pub const fn vec3(x: f32, y: f32, z: f32) -> Vec3
```

--------------------------------

### Create an I64Vec2 vector

Source: https://docs.rs/glam/latest/glam/i64/fn.i64vec2.html

Initializes a new 2-dimensional vector using two 64-bit integer values.

```rust
pub const fn i64vec2(x: i64, y: i64) -> I64Vec2
```

--------------------------------

### Comparison Methods

Source: https://docs.rs/glam/latest/glam/u64/struct.U64Vec4.html?search=std%3A%3Avec

Methods for performing element-wise comparisons between two U64Vec4 instances, returning a vector mask.

```APIDOC
## cmpge(self, rhs: Self) -> BVec4
Returns a vector mask containing the result of a `>=` comparison for each element.

## cmpgt(self, rhs: Self) -> BVec4
Returns a vector mask containing the result of a `>` comparison for each element.

## cmple(self, rhs: Self) -> BVec4
Returns a vector mask containing the result of a `<=` comparison for each element.

## cmplt(self, rhs: Self) -> BVec4
Returns a vector mask containing the result of a `<` comparison for each element.
```

--------------------------------

### TryFrom Conversions

Source: https://docs.rs/glam/latest/glam/isize/struct.ISizeVec2.html?search=

Methods to convert U64Vec2, USizeVec2, or UVec2 types into ISizeVec2.

```APIDOC
## fn try_from(v: U64Vec2) -> Result<Self, Self::Error>
## fn try_from(v: USizeVec2) -> Result<Self, Self::Error>
## fn try_from(v: UVec2) -> Result<Self, Self::Error>

### Description
Performs a fallible conversion from a source vector type to ISizeVec2. Returns a TryFromIntError if the conversion fails.

### Parameters
- **v** (U64Vec2 | USizeVec2 | UVec2) - The source vector to convert.
```

--------------------------------

### Mat4 Construction Methods

Source: https://docs.rs/glam/latest/glam/f32/struct.Mat4.html

Methods for creating Mat4 instances from various transformations or data sources.

```APIDOC
## from_mat3a(m: Mat3A) -> Self
Creates an affine transformation matrix from the given 3x3 linear transformation matrix.

## from_translation(translation: Vec3) -> Self
Creates an affine transformation matrix from the given 3D translation.

## from_axis_angle(axis: Vec3, angle: f32) -> Self
Creates an affine transformation matrix containing a 3D rotation around a normalized rotation axis of angle (in radians).

## from_euler(order: EulerRot, a: f32, b: f32, c: f32) -> Self
Creates an affine transformation matrix containing a rotation from the given euler rotation sequence and angles.

## from_rotation_x(angle: f32) -> Self
Creates an affine transformation matrix containing a 3D rotation around the x axis.

## from_rotation_y(angle: f32) -> Self
Creates an affine transformation matrix containing a 3D rotation around the y axis.

## from_rotation_z(angle: f32) -> Self
Creates an affine transformation matrix containing a 3D rotation around the z axis.

## from_scale(scale: Vec3) -> Self
Creates an affine transformation matrix containing the given 3D non-uniform scale.

## from_cols_slice(slice: &[f32]) -> Self
Creates a 4x4 matrix from the first 16 values in slice.
```

--------------------------------

### Create a 2-dimensional vector

Source: https://docs.rs/glam/latest/glam/usize/fn.usizevec2.html

Initializes a new USizeVec2 instance with the provided x and y coordinates.

```rust
pub const fn usizevec2(x: usize, y: usize) -> USizeVec2
```

--------------------------------

### TryFrom Conversions

Source: https://docs.rs/glam/latest/glam/u16/struct.U16Vec4.html?search=std%3A%3Avec

Conversions to and from U16Vec4 using the TryFrom trait.

```APIDOC
## TryFrom Conversions

### Description
Converts between U16Vec4 and other vector types (ISizeVec4, U64Vec4, USizeVec4, UVec4). These operations may fail and return a TryFromIntError.

### Methods
- try_from(v: U16Vec4) -> Result<ISizeVec4, TryFromIntError>
- try_from(v: U64Vec4) -> Result<U16Vec4, TryFromIntError>
- try_from(v: USizeVec4) -> Result<U16Vec4, TryFromIntError>
- try_from(v: UVec4) -> Result<U16Vec4, TryFromIntError>
```

--------------------------------

### TryFrom Conversions

Source: https://docs.rs/glam/latest/glam/u64/struct.U64Vec4.html?search=

Conversions between U64Vec4 and other vector types (UVec4, I64Vec4, USizeVec4, ISizeVec4).

```APIDOC
## TryFrom<U64Vec4> for [TargetType]

### Description
Converts a U64Vec4 instance into another vector type. Requires the `u64` crate feature.

### Method
try_from(v: U64Vec4) -> Result<Self, Self::Error>

### Parameters
- **v** (U64Vec4) - The source vector to convert.

### Response
- **Result<Self, TryFromIntError>** - Returns the converted vector or a conversion error.
```

--------------------------------

### TryFrom Conversions

Source: https://docs.rs/glam/latest/glam/i8/struct.I8Vec3.html?search=std%3A%3Avec

Implementations of the TryFrom trait for converting I8Vec3 to and from various other vector types, subject to specific crate features.

```APIDOC
## fn try_from(v: T) -> Result<Self, Self::Error>

### Description
Performs a fallible conversion between I8Vec3 and another vector type (e.g., U8Vec3, I16Vec3, etc.).

### Parameters
- **v** (T) - Required - The source vector to convert.

### Response
- **Result<Self, TryFromIntError>** - Returns the converted vector or a TryFromIntError if the conversion fails.
```

--------------------------------

### Create a 4-dimensional vector

Source: https://docs.rs/glam/latest/glam/u64/fn.u64vec4.html

Initializes a new U64Vec4 instance using four 64-bit unsigned integer values.

```rust
pub const fn u64vec4(x: u64, y: u64, z: u64, w: u64) -> U64Vec4
```

--------------------------------

### Vector Creation Functions

Source: https://docs.rs/glam/latest/glam/u16/index.html?search=std%3A%3Avec

Helper functions to create instances of u16 vector types.

```APIDOC
## Functions

- **u16vec2()**: Creates a 2-dimensional vector.
- **u16vec3()**: Creates a 3-dimensional vector.
- **u16vec4()**: Creates a 4-dimensional vector.
```

--------------------------------

### pub const fn quat(x: f32, y: f32, z: f32, w: f32) -> Quat

Source: https://docs.rs/glam/latest/glam/f32/fn.quat.html?search=u32+-%3E+bool

Creates a quaternion from x, y, z and w values. This should generally not be called manually unless you know what you are doing. Use one of the other constructors instead such as identity or from_axis_angle.

```APIDOC
## Function: quat

### Description
Creates a quaternion from x, y, z and w values. This should generally not be called manually unless you know what you are doing. Use one of the other constructors instead such as identity or from_axis_angle.

### Signature
`pub const fn quat(x: f32, y: f32, z: f32, w: f32) -> Quat`

### Parameters
- **x** (f32) - The x component of the quaternion.
- **y** (f32) - The y component of the quaternion.
- **z** (f32) - The z component of the quaternion.
- **w** (f32) - The w component of the quaternion.

### Returns
- **Quat** - A new quaternion instance.
```

--------------------------------

### Convert between Vec3, Vec3A, and Vec4

Source: https://docs.rs/glam/latest/glam/index.html

Demonstrates conversion methods between SIMD-optimized Vec3A and standard Vec3/Vec4 types.

```rust
use glam::{Vec3, Vec3A, Vec4};

let v4 = Vec4::new(1.0, 2.0, 3.0, 4.0);

// Convert from `Vec4` to `Vec3A`, this is a no-op if SIMD is supported.
// We use an explicit method here instead of a From impl as data is lost in the conversion.
let v3a = Vec3A::from_vec4(v4);
assert_eq!(Vec3A::new(1.0, 2.0, 3.0), v3a);

// Convert from `Vec3A` to `Vec3`.
let v3 = Vec3::from(v3a);
assert_eq!(Vec3::new(1.0, 2.0, 3.0), v3);

// Convert from `Vec3` to `Vec3A`.
let v3a = Vec3A::from(v3);
assert_eq!(Vec3A::new(1.0, 2.0, 3.0), v3a);
```

--------------------------------

### pub const fn quat(x: f32, y: f32, z: f32, w: f32) -> Quat

Source: https://docs.rs/glam/latest/glam/f32/fn.quat.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Creates a quaternion from x, y, z and w values. It is recommended to use other constructors like identity or from_axis_angle instead of calling this manually.

```APIDOC
## Function: quat

### Description
Creates a quaternion from `x`, `y`, `z` and `w` values. This should generally not be called manually unless you know what you are doing. Use one of the other constructors instead such as `identity` or `from_axis_angle`.

### Signature
`pub const fn quat(x: f32, y: f32, z: f32, w: f32) -> Quat`

### Parameters
- **x** (f32) - The x component of the quaternion.
- **y** (f32) - The y component of the quaternion.
- **z** (f32) - The z component of the quaternion.
- **w** (f32) - The w component of the quaternion.

### Returns
- **Quat** - A new quaternion instance.
```

--------------------------------

### Create a 3-dimensional vector

Source: https://docs.rs/glam/latest/glam/i64/fn.i64vec3.html

Constructs an I64Vec3 instance using three 64-bit integer components.

```rust
pub const fn i64vec3(x: i64, y: i64, z: i64) -> I64Vec3
```

--------------------------------

### Swizzling Methods

Source: https://docs.rs/glam/latest/glam/u16/struct.U16Vec4.html

Methods to extract components into smaller vector types (U16Vec2, U16Vec3) or create new U16Vec4 instances.

```APIDOC
## Swizzling Methods

### Description
These methods allow for component reordering and extraction from a U16Vec4 instance. Methods returning U16Vec2 or U16Vec3 extract specific components, while methods returning Self (U16Vec4) create a new vector with reordered components.

### Methods
- **fn [component_combination](self) -> [ReturnType]**

### Parameters
- **self** - The source U16Vec4 instance.

### Returns
- **U16Vec2/U16Vec3/Self** - A new vector containing the specified components.
```

--------------------------------

### Create a 4-dimensional vector

Source: https://docs.rs/glam/latest/glam/i8/fn.i8vec4.html

Constructs an I8Vec4 instance from four 8-bit signed integers.

```rust
pub const fn i8vec4(x: i8, y: i8, z: i8, w: i8) -> I8Vec4
```

--------------------------------

### Create a 3x3 matrix from column vectors

Source: https://docs.rs/glam/latest/glam/f32/fn.mat3.html?search=

Constructs a Mat3 instance using three Vec3 column vectors.

```rust
pub const fn mat3(x_axis: Vec3, y_axis: Vec3, z_axis: Vec3) -> Mat3
```

--------------------------------

### Construct a Quat from components

Source: https://docs.rs/glam/latest/glam/f32/fn.quat.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Creates a quaternion from x, y, z, and w values. Avoid manual calls in favor of specialized constructors.

```rust
pub const fn quat(x: f32, y: f32, z: f32, w: f32) -> Quat
```

--------------------------------

### Create a 2D u16 vector

Source: https://docs.rs/glam/latest/glam/u16/fn.u16vec2.html

Initializes a new U16Vec2 instance using the provided x and y coordinates.

```rust
pub const fn u16vec2(x: u16, y: u16) -> U16Vec2
```

--------------------------------

### BVec4A Methods

Source: https://docs.rs/glam/latest/glam/bool/struct.BVec4A.html?search=std%3A%3Avec

Core methods for creating and manipulating BVec4A instances.

```APIDOC
## BVec4A::new(x: bool, y: bool, z: bool, w: bool) -> Self
Creates a new vector mask.

## BVec4A::splat(v: bool) -> Self
Creates a vector mask with all elements set to `v`.

## BVec4A::from_array(a: [bool; 4]) -> Self
Creates a new vector mask from a bool array.

## BVec4A::bitmask(self) -> u32
Returns a bitmask with the lowest 4 bits set from the elements of `self`. A true element results in a 1 bit and a false element in a 0 bit.

## BVec4A::any(self) -> bool
Returns true if any of the elements are true, false otherwise.

## BVec4A::all(self) -> bool
Returns true if all the elements are true, false otherwise.

## BVec4A::test(self, index: usize) -> bool
Tests the value at `index`. Panics if `index` is greater than 3.

## BVec4A::set(&mut self, index: usize, value: bool)
Sets the element at `index`. Panics if `index` is greater than 3.
```

--------------------------------

### Create a 2-dimensional vector

Source: https://docs.rs/glam/latest/glam/u64/fn.u64vec2.html

Constructs a U64Vec2 instance using two u64 values.

```rust
pub const fn u64vec2(x: u64, y: u64) -> U64Vec2
```

--------------------------------

### Swizzle and Permutation Methods

Source: https://docs.rs/glam/latest/glam/u16/struct.U16Vec4.html?search=std%3A%3Avec

Methods for accessing vector components in different orders or creating new vectors from existing components.

```APIDOC
## Swizzle Methods

These methods extract components from a `U16Vec4` to return a `U16Vec3`.

- `zwy(self) -> U16Vec3`
- `zwz(self) -> U16Vec3`
- `zww(self) -> U16Vec3`
- `wxx(self) -> U16Vec3`
- `wxy(self) -> U16Vec3`
- `wxz(self) -> U16Vec3`
- `wxw(self) -> U16Vec3`
- `wyx(self) -> U16Vec3`
- `wyy(self) -> U16Vec3`
- `wyz(self) -> U16Vec3`
- `wyw(self) -> U16Vec3`
- `wzx(self) -> U16Vec3`
- `wzy(self) -> U16Vec3`
- `wzz(self) -> U16Vec3`
- `wzw(self) -> U16Vec3`
- `wwx(self) -> U16Vec3`
- `wwy(self) -> U16Vec3`
- `wwz(self) -> U16Vec3`
- `www(self) -> U16Vec3`

## Permutation Methods

These methods return a new `U16Vec4` with reordered components.

- `xxxx(self) -> Self`
- `xxxy(self) -> Self`
- `xxxz(self) -> Self`
- `xxxw(self) -> Self`
- `xxyx(self) -> Self`
- `xxyy(self) -> Self`
- `xxyz(self) -> Self`
- `xxyw(self) -> Self`
- `xxzx(self) -> Self`
- `xxzy(self) -> Self`
- `xxzz(self) -> Self`
- `xxzw(self) -> Self`
- `xxwx(self) -> Self`
- `xxwy(self) -> Self`
- `xxwz(self) -> Self`
- `xxww(self) -> Self`
- `xyxx(self) -> Self`
- `xyxy(self) -> Self`
- `xyxz(self) -> Self`
- `xyxw(self) -> Self`
- `xyyx(self) -> Self`
- `xyyy(self) -> Self`
- `xyyz(self) -> Self`
- `xyyw(self) -> Self`
- `xyzx(self) -> Self`
- `xyzy(self) -> Self`
- `xyzz(self) -> Self`
- `xywx(self) -> Self`
- `xywy(self) -> Self`
- `xywz(self) -> Self`
- `xyww(self) -> Self`
- `xzxx(self) -> Self`
- `xzxy(self) -> Self`
- `xzxz(self) -> Self`
- `xzxw(self) -> Self`
- `xzyx(self) -> Self`
- `xzyy(self) -> Self`
- `xzyz(self) -> Self`
- `xzyw(self) -> Self`
- `xzzx(self) -> Self`
- `xzzy(self) -> Self`
- `xzzz(self) -> Self`
- `xzzw(self) -> Self`
- `xzwx(self) -> Self`
- `xzwy(self) -> Self`
- `xzwz(self) -> Self`
- `xzww(self) -> Self`
- `xwxx(self) -> Self`
- `xwxy(self) -> Self`
- `xwxz(self) -> Self`
- `xwxw(self) -> Self`
- `xwyx(self) -> Self`
- `xwyy(self) -> Self`
- `xwyz(self) -> Self`
- `xwyw(self) -> Self`
- `xwzx(self) -> Self`
- `xwzy(self) -> Self`
- `xwzz(self) -> Self`
- `xwzw(self) -> Self`
- `xwwx(self) -> Self`
- `xwwy(self) -> Self`
- `xwwz(self) -> Self`
- `xwww(self) -> Self`
- `yxxx(self) -> Self`
- `yxxy(self) -> Self`
- `yxxz(self) -> Self`
- `yxxw(self) -> Self`
- `yxyx(self) -> Self`
- `yxyy(self) -> Self`
- `yxyz(self) -> Self`
- `yxyw(self) -> Self`
- `yxzx(self) -> Self`
- `yxzy(self) -> Self`
- `yxzz(self) -> Self`
- `yxzw(self) -> Self`
- `yxwx(self) -> Self`
- `yxwy(self) -> Self`
- `yxwz(self) -> Self`
- `yxww(self) -> Self`
- `yyxx(self) -> Self`
- `yyxy(self) -> Self`
- `yyxz(self) -> Self`
- `yyxw(self) -> Self`
- `yyyx(self) -> Self`
- `yyyy(self) -> Self`
- `yyyz(self) -> Self`
- `yyyw(self) -> Self`
- `yyzx(self) -> Self`
- `yyzy(self) -> Self`
- `yyzz(self) -> Self`
- `yyzw(self) -> Self`
- `yywx(self) -> Self`
- `yywy(self) -> Self`
- `yywz(self) -> Self`
- `yyww(self) -> Self`
- `yzxx(self) -> Self`
- `yzxy(self) -> Self`
- `yzxz(self) -> Self`
- `yzxw(self) -> Self`
- `yzyx(self) -> Self`
- `yzyy(self) -> Self`
- `yzyz(self) -> Self`
- `yzyw(self) -> Self`
- `yzzx(self) -> Self`
- `yzzy(self) -> Self`
- `yzzz(self) -> Self`
- `yzzw(self) -> Self`
- `yzwx(self) -> Self`
- `yzwy(self) -> Self`
- `yzwz(self) -> Self`
- `yzww(self) -> Self`
- `ywxx(self) -> Self`
```

--------------------------------

### TryFrom Conversions

Source: https://docs.rs/glam/latest/glam/usize/struct.USizeVec4.html?search=std%3A%3Avec

Methods for converting USizeVec4 to and from other vector types like UVec4, I64Vec4, U64Vec4, and ISizeVec4.

```APIDOC
## TryFrom<USizeVec4> Conversions

### Description
Converts a USizeVec4 instance into other vector types (UVec4, I64Vec4, U64Vec4, ISizeVec4). These operations may return a TryFromIntError if the conversion is not possible.

### Method
try_from(v: USizeVec4) -> Result<Self, Self::Error>
```

--------------------------------

### Construct a 3x3 matrix using dmat3

Source: https://docs.rs/glam/latest/glam/f64/fn.dmat3.html

Creates a DMat3 instance by providing three DVec3 column vectors as arguments.

```rust
pub const fn dmat3(x_axis: DVec3, y_axis: DVec3, z_axis: DVec3) -> DMat3
```

--------------------------------

### Verify SIMD and Scalar Formatting Consistency

Source: https://docs.rs/glam/latest/glam/index.html

Confirms that SIMD-backed types implement formatting traits to match scalar output.

```rust
use glam::Vec4;
let a = Vec4::new(1.0, 2.0, 3.0, 4.0);
assert_eq!(format!("{}", a), "[1, 2, 3, 4]");
```

--------------------------------

### pub const fn u64vec4(x: u64, y: u64, z: u64, w: u64) -> U64Vec4

Source: https://docs.rs/glam/latest/glam/u64/fn.u64vec4.html?search=u32+-%3E+bool

Creates a 4-dimensional vector from four u64 components.

```APIDOC
## Function: u64vec4

### Description
Creates a 4-dimensional vector (U64Vec4) using the provided x, y, z, and w components.

### Signature
`pub const fn u64vec4(x: u64, y: u64, z: u64, w: u64) -> U64Vec4`

### Parameters
- **x** (u64) - The x component of the vector.
- **y** (u64) - The y component of the vector.
- **z** (u64) - The z component of the vector.
- **w** (u64) - The w component of the vector.

### Returns
- **U64Vec4** - A new 4-dimensional vector instance.
```

--------------------------------

### Create a 2x2 matrix using dmat2

Source: https://docs.rs/glam/latest/glam/f64/fn.dmat2.html

Constructs a DMat2 matrix by providing two DVec2 column vectors.

```rust
pub const fn dmat2(x_axis: DVec2, y_axis: DVec2) -> DMat2
```

--------------------------------

### Create a 2-dimensional vector

Source: https://docs.rs/glam/latest/glam/f64/fn.dvec2.html

Initializes a DVec2 instance using two f64 values.

```rust
pub const fn dvec2(x: f64, y: f64) -> DVec2
```

--------------------------------

### Create a 2D vector

Source: https://docs.rs/glam/latest/glam/f32/fn.vec2.html?search=

Initializes a new Vec2 instance using two f32 values.

```rust
pub const fn vec2(x: f32, y: f32) -> Vec2
```

--------------------------------

### TryFrom<UVec3> Implementations

Source: https://docs.rs/glam/latest/glam/u32/struct.UVec3.html?search=u32+-%3E+bool

The UVec3 type implements TryFrom for I16Vec3, U16Vec3, IVec3, USizeVec3, and ISizeVec3. These conversions are available when the u32 crate feature is enabled and may return a TryFromIntError if the conversion fails.

```APIDOC
## fn try_from(v: UVec3) -> Result<Self, Self::Error>

### Description
Performs a fallible conversion from UVec3 to another vector type (I16Vec3, U16Vec3, IVec3, USizeVec3, or ISizeVec3).

### Parameters
- **v** (UVec3) - The source vector to convert.

### Returns
- **Result<Self, Self::Error>** - Returns the converted vector on success, or a TryFromIntError if the values cannot be represented in the target type.
```

--------------------------------

### dquat(x: f64, y: f64, z: f64, w: f64) -> DQuat

Source: https://docs.rs/glam/latest/glam/f64/fn.dquat.html?search=

Creates a quaternion from x, y, z, and w values. It is recommended to use other constructors like identity or from_axis_angle instead of calling this manually.

```APIDOC
## Function: dquat

### Description
Creates a double-precision quaternion (DQuat) from four f64 components (x, y, z, w).

### Signature
`pub const fn dquat(x: f64, y: f64, z: f64, w: f64) -> DQuat`

### Parameters
- **x** (f64) - The x component of the quaternion.
- **y** (f64) - The y component of the quaternion.
- **z** (f64) - The z component of the quaternion.
- **w** (f64) - The w component of the quaternion.

### Returns
- **DQuat** - A new double-precision quaternion instance.
```

--------------------------------

### dquat(x: f64, y: f64, z: f64, w: f64) -> DQuat

Source: https://docs.rs/glam/latest/glam/f64/fn.dquat.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Creates a quaternion from x, y, z, and w values. It is recommended to use other constructors like identity or from_axis_angle instead of calling this manually.

```APIDOC
## Function: dquat

### Description
Creates a double-precision quaternion (DQuat) from the provided x, y, z, and w components.

### Signature
`pub const fn dquat(x: f64, y: f64, z: f64, w: f64) -> DQuat`

### Parameters
- **x** (f64) - The x component of the quaternion.
- **y** (f64) - The y component of the quaternion.
- **z** (f64) - The z component of the quaternion.
- **w** (f64) - The w component of the quaternion.

### Returns
- **DQuat** - A new double-precision quaternion instance.
```

--------------------------------

### dquat(x: f64, y: f64, z: f64, w: f64) -> DQuat

Source: https://docs.rs/glam/latest/glam/f64/fn.dquat.html

Creates a quaternion from x, y, z and w values. It is recommended to use other constructors like identity or from_axis_angle instead of calling this manually.

```APIDOC
## Function: dquat

### Description
Creates a new `DQuat` (double-precision quaternion) from the provided `x`, `y`, `z`, and `w` components.

### Signature
`pub const fn dquat(x: f64, y: f64, z: f64, w: f64) -> DQuat`

### Parameters
- **x** (f64) - The x component of the quaternion.
- **y** (f64) - The y component of the quaternion.
- **z** (f64) - The z component of the quaternion.
- **w** (f64) - The w component of the quaternion.

### Returns
- **DQuat** - A new quaternion instance constructed from the input values.
```

--------------------------------

### as_mat3

Source: https://docs.rs/glam/latest/glam/f64/struct.DMat3.html?search=u32+-%3E+bool

Converts the DMat3 to a Mat3.

```APIDOC
## pub fn as_mat3(&self) -> Mat3

### Description
Converts the current DMat3 instance into a Mat3 type.
```

--------------------------------

### USizeVec4 Methods

Source: https://docs.rs/glam/latest/glam/usize/struct.USizeVec4.html?search=std%3A%3Avec

A collection of methods available on the USizeVec4 structure for vector manipulation.

```APIDOC
## Methods

- **wwxx**(self) -> Self
- **wwxy**(self) -> Self
- **wwxz**(self) -> Self
- **wwxw**(self) -> Self
- **wwyx**(self) -> Self
- **wwyy**(self) -> Self
- **wwyz**(self) -> Self
- **wwyw**(self) -> Self
- **wwzx**(self) -> Self
- **wwzy**(self) -> Self
- **wwzz**(self) -> Self
- **wwzw**(self) -> Self
- **wwwx**(self) -> Self
- **wwwy**(self) -> Self
- **wwwz**(self) -> Self
- **wwww**(self) -> Self
- **xyzw**(self) -> Self
```

--------------------------------

### Create a 3x3 matrix from column vectors

Source: https://docs.rs/glam/latest/glam/f32/fn.mat3a.html

Constructs a Mat3A instance by providing three Vec3A column vectors.

```rust
pub const fn mat3a(x_axis: Vec3A, y_axis: Vec3A, z_axis: Vec3A) -> Mat3A
```

--------------------------------

### Create an I8Vec2 vector

Source: https://docs.rs/glam/latest/glam/i8/fn.i8vec2.html

Initializes a new 2-dimensional vector using two i8 values.

```rust
pub const fn i8vec2(x: i8, y: i8) -> I8Vec2
```

--------------------------------

### Create a 4-dimensional vector

Source: https://docs.rs/glam/latest/glam/i64/fn.i64vec4.html

Constructs an I64Vec4 instance from four i64 components.

```rust
pub const fn i64vec4(x: i64, y: i64, z: i64, w: i64) -> I64Vec4
```

--------------------------------

### Create a 3-dimensional vector

Source: https://docs.rs/glam/latest/glam/u16/fn.u16vec3.html

Use this function to initialize a new U16Vec3 instance with the specified x, y, and z components.

```rust
pub const fn u16vec3(x: u16, y: u16, z: u16) -> U16Vec3
```

--------------------------------

### Create a 2D vector with ivec2

Source: https://docs.rs/glam/latest/glam/i32/fn.ivec2.html

Constructs an IVec2 instance using two i32 coordinates.

```rust
pub const fn ivec2(x: i32, y: i32) -> IVec2
```

--------------------------------

### Mat2 Methods

Source: https://docs.rs/glam/latest/glam/f32/struct.Mat2.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Core methods available on the Mat2 structure for matrix arithmetic and transformation.

```APIDOC
## pub fn add_mat2(&self, rhs: &Self) -> Self
Adds two 2x2 matrices.

## pub fn sub_mat2(&self, rhs: &Self) -> Self
Subtracts two 2x2 matrices.

## pub fn mul_scalar(&self, rhs: f32) -> Self
Multiplies a 2x2 matrix by a scalar.

## pub fn mul_diagonal_scale(&self, scale: Vec2) -> Self
Multiply `self` by a scaling vector `scale`. This is faster than creating a whole diagonal scaling matrix and then multiplying that.

## pub fn div_scalar(&self, rhs: f32) -> Self
Divides a 2x2 matrix by a scalar.

## pub fn recip(&self) -> Self
Returns a matrix containing the reciprocal `1.0/n` of each element of `self`.

## pub fn abs_diff_eq(&self, rhs: Self, max_abs_diff: f32) -> bool
Returns true if the absolute difference of all elements between `self` and `rhs` is less than or equal to `max_abs_diff`.

## pub fn abs(&self) -> Self
Takes the absolute value of each element in `self`.

## pub fn as_dmat2(&self) -> DMat2
Converts the matrix to a double-precision 2x2 matrix.
```

--------------------------------

### TryFrom<UVec4> for U8Vec4

Source: https://docs.rs/glam/latest/glam/u8/struct.U8Vec4.html?search=

Converts a UVec4 into a U8Vec4. This operation is available when the u32 crate feature is enabled.

```APIDOC
## fn try_from(v: UVec4) -> Result<Self, Self::Error>

### Description
Performs the conversion from a UVec4 to a U8Vec4. Returns a Result containing the U8Vec4 or a TryFromIntError if the conversion fails.
```

--------------------------------

### Create a 3-dimensional vector

Source: https://docs.rs/glam/latest/glam/f64/fn.dvec3.html

Initializes a new DVec3 instance using three f64 values.

```rust
pub const fn dvec3(x: f64, y: f64, z: f64) -> DVec3
```

--------------------------------

### Swizzling Methods

Source: https://docs.rs/glam/latest/glam/f64/struct.DVec4.html

Methods for extracting DVec3 components or creating new DVec4 instances from existing DVec4 data.

```APIDOC
## Swizzling Methods

### Description
These methods allow for the extraction of 3-component vectors (DVec3) from a 4-component vector (DVec4) or the creation of a new DVec4 by reordering components.

### Methods
- **zzx() -> DVec3**: Extracts the z, z, and x components.
- **zzy() -> DVec3**: Extracts the z, z, and y components.
- **zzz() -> DVec3**: Extracts the z, z, and z components.
- **zzw() -> DVec3**: Extracts the z, z, and w components.
- **xxxx() -> Self**: Returns a new DVec4 with all components set to x.
- **xyxy() -> Self**: Returns a new DVec4 with components reordered as x, y, x, y.

### Usage
These methods are used for vector manipulation and component access in 4D space.
```
Tokens:
Raw