Struct shades::expr::Expr

pub struct Expr<T> where
    T: ?Sized, { /* private fields */ }

Expression representation.

An expression is anything that carries a (typed) value and that can be combined in various ways with other expressions. A literal, a constant or a variable are all expressions. The sum (as in a + b) of two expressions is also an expression. A function call returning an expression is also an expression, as in a * sin(b). Accessing an element in an array (which is an expression as it carries items) via an index (an expression) is also an expression — e.g. levels[y * HEIGHT + x] * size. The same thing applies to field access, swizzling, etc. etc.

On a general note, expressions are pretty central to the EDSL, as they are the lower level concept you will be able to manipulate. Expressions are side effect free, so a variable, for instance, can either be considered as an expression or not. If x is a variable (see Var), then x * 10 is an expression, but using x to mutate its content does not make a use of x as an expression. It means that expressions are read-only and even though you can go from higher constructs (like variables) to expressions, the opposite direction is forbidden.

Literals

The most obvious kind of expression is a literal — e.g. 1, false, 3.14, etc. Any type T that defines an implementor From<T> for Expr<T> can be used as literal. You can then use, for instance, 1.into(), Expr::from(1), etc.

That is a concern of yours only if you do not use shades-edsl.

Expressions from side-effects

Some side-effects will create expressions, such as creating a variable or a constant. Most of the time, you shouldn’t have to worry about the type of the expression as it should be inferred based on the side-effect.

Expression macros

Some macros will create expressions for you, such as vec2!, vec3! and vec4! or the sw! macros.

Implementations

impl<T> Expr<T> where
    T: ?Sized, 

pub const fn new(erased: ErasedExpr) -> Self

Type an ErasedExpr and return it wrapped in Expr<T>.

pub const fn new_input(handle: u16) -> Self

Create a new input.

You should use this function when implementing [Inputs::input()].

pub fn new_output(handle: u16) -> Self

Create a new output.

You should use this function when implementing [Outputs::output()].

pub fn new_env(name: impl Into<String>) -> Self

Create a new environment variable.

You should use this function when implementing [Environment::env()].

pub const fn new_fun_arg(handle: u16) -> Self

Create a new function argument.

You shouldn’t have to use that function, as its main purpose is to be used by shades-edsl.

pub fn eq(&self, rhs: impl Into<Expr<T>>) -> Expr<bool>

Equality expression.

This method builds an expression representing the equality between two expressions.

Return

An Expr<bool> representing the equality between the two input expressions.

pub fn neq(&self, rhs: impl Into<Expr<T>>) -> Expr<bool>

Inequality expression.

This method builds an expression representing the inequality between two expressions.

Return

An Expr<bool> representing the inequality between the two input expressions.

impl<T> Expr<T> where
    T: PartialOrd, 

pub fn lt(&self, rhs: impl Into<Expr<T>>) -> Expr<bool>

Less-than expression.

This method builds an expression representing the binary operation a < b.

Return

An Expr<bool> representing a < b.

pub fn lte(&self, rhs: impl Into<Expr<T>>) -> Expr<bool>

Less-than-or-equal expression.

This method builds an expression representing the binary operation a <= b.

Return

An Expr<bool> representing a <= b.

pub fn gt(&self, rhs: impl Into<Expr<T>>) -> Expr<bool>

Greater-than expression.

This method builds an expression representing the binary operation a > b.

Return

An Expr<bool> representing a > b.

pub fn gte(&self, rhs: impl Into<Expr<T>>) -> Expr<bool>

Less-than-or-equal expression.

This method builds an expression representing the binary operation a <= b.

Return

An Expr<bool> representing a <= b.

impl Expr<bool>

pub fn and(&self, rhs: impl Into<Expr<bool>>) -> Expr<bool>

Logical and expression.

This method builds an expression representing the logical operation a AND b.

Return

An Expr<bool> representing a AND b.

pub fn or(&self, rhs: impl Into<Expr<bool>>) -> Expr<bool>

Logical or expression.

This method builds an expression representing the logical operation a OR b.

Return

An Expr<bool> representing a OR b.

pub fn xor(&self, rhs: impl Into<Expr<bool>>) -> Expr<bool>

Logical exclusive or expression.

This method builds an expression representing the logical operation a XOR b.

Return

An Expr<bool> representing a XOR b.

impl<T> Expr<[T]>

pub fn at(&self, index: Expr<i32>) -> Expr<T>

Array lookup.

The expression a.at(i) represents an array lookup, where a is an array — which type must be either Expr<[T]> or Expr<[T; N]> – and i is an Expr<i32>.

Return

The resulting Expr<T> represents the array lookup in a at index i.

impl<T, const N: usize> Expr<[T; N]>

pub fn at(&self, index: impl Into<Expr<i32>>) -> Expr<T>

Array lookup.

The expression a.at(i) represents an array lookup, where a is an array — which type must be either Expr<[T]> or Expr<[T; N]> – and i is an Expr<i32>.

Return

The resulting Expr<T> represents the array lookup in a at index i.

impl Expr<TessControlPerVertexIn>

pub fn position(&self) -> Expr<V4<f32>>

pub fn point_size(&self) -> Expr<f32>

pub fn clip_distance(&self) -> Expr<[f32]>

pub fn cull_distance(&self) -> Expr<[f32]>

impl Expr<TessEvaluationPerVertexIn>

pub fn position(&self) -> Expr<V4<f32>>

4D position of the vertex.

pub fn point_size(&self) -> Expr<f32>

Point size of the vertex.

pub fn clip_distance(&self) -> Expr<[f32]>

Clip distances to user-defined planes.

pub fn cull_distance(&self) -> Expr<[f32]>

Cull distances to user-defined planes.

impl Expr<GeometryPerVertexIn>

pub fn position(&self) -> Expr<V4<f32>>

Provides 4D the position of the vertex.

pub fn point_size(&self) -> Expr<f32>

Provides the size point of the vertex if it’s currently being rendered in point mode.

pub fn clip_distance(&self) -> Expr<[f32]>

Clip distances to user planes of the vertex.

pub fn cull_distance(&self) -> Expr<[f32]>

Cull distances to user planes of the vertex.

impl Expr<TessControlPerVertexOut>

pub fn position(&self) -> Var<V4<f32>>

4D position of the vertex.

pub fn point_size(&self) -> Var<f32>

Point size of the vertex.

pub fn clip_distance(&self) -> Var<[f32]>

Clip distances to user-defined planes.

pub fn cull_distance(&self) -> Var<[f32]>

Cull distances to user-defined planes.

Trait Implementations

impl<'a> Add<Expr<V2<f32>>> for Expr<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the + operator.

fn add(self, rhs: Expr<V2<f32>>) -> Self::Output

Performs the + operation.

impl<'a> Add<Expr<V2<i32>>> for Expr<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the + operator.

fn add(self, rhs: Expr<V2<i32>>) -> Self::Output

Performs the + operation.

impl<'a> Add<Expr<V2<u32>>> for Expr<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the + operator.

fn add(self, rhs: Expr<V2<u32>>) -> Self::Output

Performs the + operation.

impl<'a> Add<Expr<V3<f32>>> for Expr<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the + operator.

fn add(self, rhs: Expr<V3<f32>>) -> Self::Output

Performs the + operation.

impl<'a> Add<Expr<V3<i32>>> for Expr<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the + operator.

fn add(self, rhs: Expr<V3<i32>>) -> Self::Output

Performs the + operation.

impl<'a> Add<Expr<V3<u32>>> for Expr<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the + operator.

fn add(self, rhs: Expr<V3<u32>>) -> Self::Output

Performs the + operation.

impl<'a> Add<Expr<V4<f32>>> for Expr<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the + operator.

fn add(self, rhs: Expr<V4<f32>>) -> Self::Output

Performs the + operation.

impl<'a> Add<Expr<V4<i32>>> for Expr<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the + operator.

fn add(self, rhs: Expr<V4<i32>>) -> Self::Output

Performs the + operation.

impl<'a> Add<Expr<V4<u32>>> for Expr<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the + operator.

fn add(self, rhs: Expr<V4<u32>>) -> Self::Output

Performs the + operation.

impl<'a> Add<Expr<f32>> for Expr<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the + operator.

fn add(self, rhs: Expr<f32>) -> Self::Output

Performs the + operation.

impl<'a> Add<Expr<f32>> for Expr<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the + operator.

fn add(self, rhs: Expr<f32>) -> Self::Output

Performs the + operation.

impl<'a> Add<Expr<f32>> for Expr<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the + operator.

fn add(self, rhs: Expr<f32>) -> Self::Output

Performs the + operation.

impl<'a> Add<Expr<f32>> for Expr<f32>

type Output = Expr<f32>

The resulting type after applying the + operator.

fn add(self, rhs: Expr<f32>) -> Self::Output

Performs the + operation.

impl<'a> Add<Expr<i32>> for Expr<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the + operator.

fn add(self, rhs: Expr<i32>) -> Self::Output

Performs the + operation.

impl<'a> Add<Expr<i32>> for Expr<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the + operator.

fn add(self, rhs: Expr<i32>) -> Self::Output

Performs the + operation.

impl<'a> Add<Expr<i32>> for Expr<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the + operator.

fn add(self, rhs: Expr<i32>) -> Self::Output

Performs the + operation.

impl<'a> Add<Expr<i32>> for Expr<i32>

type Output = Expr<i32>

The resulting type after applying the + operator.

fn add(self, rhs: Expr<i32>) -> Self::Output

Performs the + operation.

impl<'a> Add<Expr<u32>> for Expr<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the + operator.

fn add(self, rhs: Expr<u32>) -> Self::Output

Performs the + operation.

impl<'a> Add<Expr<u32>> for Expr<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the + operator.

fn add(self, rhs: Expr<u32>) -> Self::Output

Performs the + operation.

impl<'a> Add<Expr<u32>> for Expr<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the + operator.

fn add(self, rhs: Expr<u32>) -> Self::Output

Performs the + operation.

impl<'a> Add<Expr<u32>> for Expr<u32>

type Output = Expr<u32>

The resulting type after applying the + operator.

fn add(self, rhs: Expr<u32>) -> Self::Output

Performs the + operation.

impl<'a> BitAnd<Expr<V2<bool>>> for Expr<V2<bool>>

type Output = Expr<V2<bool>>

The resulting type after applying the & operator.

fn bitand(self, rhs: Expr<V2<bool>>) -> Self::Output

Performs the & operation.

impl<'a> BitAnd<Expr<V3<bool>>> for Expr<V3<bool>>

type Output = Expr<V3<bool>>

The resulting type after applying the & operator.

fn bitand(self, rhs: Expr<V3<bool>>) -> Self::Output

Performs the & operation.

impl<'a> BitAnd<Expr<V4<bool>>> for Expr<V4<bool>>

type Output = Expr<V4<bool>>

The resulting type after applying the & operator.

fn bitand(self, rhs: Expr<V4<bool>>) -> Self::Output

Performs the & operation.

impl<'a> BitAnd<Expr<bool>> for Expr<V2<bool>>

type Output = Expr<V2<bool>>

The resulting type after applying the & operator.

fn bitand(self, rhs: Expr<bool>) -> Self::Output

Performs the & operation.

impl<'a> BitAnd<Expr<bool>> for Expr<V3<bool>>

type Output = Expr<V3<bool>>

The resulting type after applying the & operator.

fn bitand(self, rhs: Expr<bool>) -> Self::Output

Performs the & operation.

impl<'a> BitAnd<Expr<bool>> for Expr<V4<bool>>

type Output = Expr<V4<bool>>

The resulting type after applying the & operator.

fn bitand(self, rhs: Expr<bool>) -> Self::Output

Performs the & operation.

impl<'a> BitAnd<Expr<bool>> for Expr<bool>

type Output = Expr<bool>

The resulting type after applying the & operator.

fn bitand(self, rhs: Expr<bool>) -> Self::Output

Performs the & operation.

impl<'a> BitOr<Expr<V2<bool>>> for Expr<V2<bool>>

type Output = Expr<V2<bool>>

The resulting type after applying the | operator.

fn bitor(self, rhs: Expr<V2<bool>>) -> Self::Output

Performs the | operation.

impl<'a> BitOr<Expr<V3<bool>>> for Expr<V3<bool>>

type Output = Expr<V3<bool>>

The resulting type after applying the | operator.

fn bitor(self, rhs: Expr<V3<bool>>) -> Self::Output

Performs the | operation.

impl<'a> BitOr<Expr<V4<bool>>> for Expr<V4<bool>>

type Output = Expr<V4<bool>>

The resulting type after applying the | operator.

fn bitor(self, rhs: Expr<V4<bool>>) -> Self::Output

Performs the | operation.

impl<'a> BitOr<Expr<bool>> for Expr<V2<bool>>

type Output = Expr<V2<bool>>

The resulting type after applying the | operator.

fn bitor(self, rhs: Expr<bool>) -> Self::Output

Performs the | operation.

impl<'a> BitOr<Expr<bool>> for Expr<V3<bool>>

type Output = Expr<V3<bool>>

The resulting type after applying the | operator.

fn bitor(self, rhs: Expr<bool>) -> Self::Output

Performs the | operation.

impl<'a> BitOr<Expr<bool>> for Expr<V4<bool>>

type Output = Expr<V4<bool>>

The resulting type after applying the | operator.

fn bitor(self, rhs: Expr<bool>) -> Self::Output

Performs the | operation.

impl<'a> BitOr<Expr<bool>> for Expr<bool>

type Output = Expr<bool>

The resulting type after applying the | operator.

fn bitor(self, rhs: Expr<bool>) -> Self::Output

Performs the | operation.

impl<'a> BitXor<Expr<V2<bool>>> for Expr<V2<bool>>

type Output = Expr<V2<bool>>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Expr<V2<bool>>) -> Self::Output

Performs the ^ operation.

impl<'a> BitXor<Expr<V3<bool>>> for Expr<V3<bool>>

type Output = Expr<V3<bool>>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Expr<V3<bool>>) -> Self::Output

Performs the ^ operation.

impl<'a> BitXor<Expr<V4<bool>>> for Expr<V4<bool>>

type Output = Expr<V4<bool>>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Expr<V4<bool>>) -> Self::Output

Performs the ^ operation.

impl<'a> BitXor<Expr<bool>> for Expr<V2<bool>>

type Output = Expr<V2<bool>>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Expr<bool>) -> Self::Output

Performs the ^ operation.

impl<'a> BitXor<Expr<bool>> for Expr<V3<bool>>

type Output = Expr<V3<bool>>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Expr<bool>) -> Self::Output

Performs the ^ operation.

impl<'a> BitXor<Expr<bool>> for Expr<V4<bool>>

type Output = Expr<V4<bool>>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Expr<bool>) -> Self::Output

Performs the ^ operation.

impl<'a> BitXor<Expr<bool>> for Expr<bool>

type Output = Expr<bool>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Expr<bool>) -> Self::Output

Performs the ^ operation.

impl Bounded for Expr<V2<bool>>

fn min(self, rhs: Self) -> Self

fn max(self, rhs: Self) -> Self

fn clamp(self, min_value: Self, max_value: Self) -> Self

impl Bounded for Expr<V2<f32>>

fn min(self, rhs: Self) -> Self

fn max(self, rhs: Self) -> Self

fn clamp(self, min_value: Self, max_value: Self) -> Self

impl Bounded for Expr<V2<i32>>

fn min(self, rhs: Self) -> Self

fn max(self, rhs: Self) -> Self

fn clamp(self, min_value: Self, max_value: Self) -> Self

impl Bounded for Expr<V2<u32>>

fn min(self, rhs: Self) -> Self

fn max(self, rhs: Self) -> Self

fn clamp(self, min_value: Self, max_value: Self) -> Self

impl Bounded for Expr<V3<bool>>

fn min(self, rhs: Self) -> Self

fn max(self, rhs: Self) -> Self

fn clamp(self, min_value: Self, max_value: Self) -> Self

impl Bounded for Expr<V3<f32>>

fn min(self, rhs: Self) -> Self

fn max(self, rhs: Self) -> Self

fn clamp(self, min_value: Self, max_value: Self) -> Self

impl Bounded for Expr<V3<i32>>

fn min(self, rhs: Self) -> Self

fn max(self, rhs: Self) -> Self

fn clamp(self, min_value: Self, max_value: Self) -> Self

impl Bounded for Expr<V3<u32>>

fn min(self, rhs: Self) -> Self

fn max(self, rhs: Self) -> Self

fn clamp(self, min_value: Self, max_value: Self) -> Self

impl Bounded for Expr<V4<bool>>

fn min(self, rhs: Self) -> Self

fn max(self, rhs: Self) -> Self

fn clamp(self, min_value: Self, max_value: Self) -> Self

impl Bounded for Expr<V4<f32>>

fn min(self, rhs: Self) -> Self

fn max(self, rhs: Self) -> Self

fn clamp(self, min_value: Self, max_value: Self) -> Self

impl Bounded for Expr<V4<i32>>

fn min(self, rhs: Self) -> Self

fn max(self, rhs: Self) -> Self

fn clamp(self, min_value: Self, max_value: Self) -> Self

impl Bounded for Expr<V4<u32>>

fn min(self, rhs: Self) -> Self

fn max(self, rhs: Self) -> Self

fn clamp(self, min_value: Self, max_value: Self) -> Self

impl Bounded for Expr<bool>

fn min(self, rhs: Self) -> Self

fn max(self, rhs: Self) -> Self

fn clamp(self, min_value: Self, max_value: Self) -> Self

impl Bounded for Expr<f32>

fn min(self, rhs: Self) -> Self

fn max(self, rhs: Self) -> Self

fn clamp(self, min_value: Self, max_value: Self) -> Self

impl Bounded for Expr<i32>

fn min(self, rhs: Self) -> Self

fn max(self, rhs: Self) -> Self

fn clamp(self, min_value: Self, max_value: Self) -> Self

impl Bounded for Expr<u32>

fn min(self, rhs: Self) -> Self

fn max(self, rhs: Self) -> Self

fn clamp(self, min_value: Self, max_value: Self) -> Self

impl<T> Clone for Expr<T> where
    T: ?Sized, 

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Expr<T> where
    T: ?Sized, 

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

Formats the value using the given formatter.

impl<'a> Div<Expr<V2<f32>>> for Expr<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the / operator.

fn div(self, rhs: Expr<V2<f32>>) -> Self::Output

Performs the / operation.

impl<'a> Div<Expr<V2<i32>>> for Expr<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the / operator.

fn div(self, rhs: Expr<V2<i32>>) -> Self::Output

Performs the / operation.

impl<'a> Div<Expr<V2<u32>>> for Expr<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the / operator.

fn div(self, rhs: Expr<V2<u32>>) -> Self::Output

Performs the / operation.

impl<'a> Div<Expr<V3<f32>>> for Expr<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the / operator.

fn div(self, rhs: Expr<V3<f32>>) -> Self::Output

Performs the / operation.

impl<'a> Div<Expr<V3<i32>>> for Expr<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the / operator.

fn div(self, rhs: Expr<V3<i32>>) -> Self::Output

Performs the / operation.

impl<'a> Div<Expr<V3<u32>>> for Expr<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the / operator.

fn div(self, rhs: Expr<V3<u32>>) -> Self::Output

Performs the / operation.

impl<'a> Div<Expr<V4<f32>>> for Expr<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the / operator.

fn div(self, rhs: Expr<V4<f32>>) -> Self::Output

Performs the / operation.

impl<'a> Div<Expr<V4<i32>>> for Expr<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the / operator.

fn div(self, rhs: Expr<V4<i32>>) -> Self::Output

Performs the / operation.

impl<'a> Div<Expr<V4<u32>>> for Expr<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the / operator.

fn div(self, rhs: Expr<V4<u32>>) -> Self::Output

Performs the / operation.

impl<'a> Div<Expr<f32>> for Expr<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the / operator.

fn div(self, rhs: Expr<f32>) -> Self::Output

Performs the / operation.

impl<'a> Div<Expr<f32>> for Expr<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the / operator.

fn div(self, rhs: Expr<f32>) -> Self::Output

Performs the / operation.

impl<'a> Div<Expr<f32>> for Expr<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the / operator.

fn div(self, rhs: Expr<f32>) -> Self::Output

Performs the / operation.

impl<'a> Div<Expr<f32>> for Expr<f32>

type Output = Expr<f32>

The resulting type after applying the / operator.

fn div(self, rhs: Expr<f32>) -> Self::Output

Performs the / operation.

impl<'a> Div<Expr<i32>> for Expr<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the / operator.

fn div(self, rhs: Expr<i32>) -> Self::Output

Performs the / operation.

impl<'a> Div<Expr<i32>> for Expr<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the / operator.

fn div(self, rhs: Expr<i32>) -> Self::Output

Performs the / operation.

impl<'a> Div<Expr<i32>> for Expr<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the / operator.

fn div(self, rhs: Expr<i32>) -> Self::Output

Performs the / operation.

impl<'a> Div<Expr<i32>> for Expr<i32>

type Output = Expr<i32>

The resulting type after applying the / operator.

fn div(self, rhs: Expr<i32>) -> Self::Output

Performs the / operation.

impl<'a> Div<Expr<u32>> for Expr<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the / operator.

fn div(self, rhs: Expr<u32>) -> Self::Output

Performs the / operation.

impl<'a> Div<Expr<u32>> for Expr<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the / operator.

fn div(self, rhs: Expr<u32>) -> Self::Output

Performs the / operation.

impl<'a> Div<Expr<u32>> for Expr<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the / operator.

fn div(self, rhs: Expr<u32>) -> Self::Output

Performs the / operation.

impl<'a> Div<Expr<u32>> for Expr<u32>

type Output = Expr<u32>

The resulting type after applying the / operator.

fn div(self, rhs: Expr<u32>) -> Self::Output

Performs the / operation.

impl<T> Erased for Expr<T>

type Erased = ErasedExpr

Erased version.

fn to_erased(self) -> Self::Erased

Consumer the typed interface and return the erased version.

fn erased(&self) -> &Self::Erased

Immutable access to the erased version.

fn erased_mut(&mut self) -> &mut Self::Erased

Mutable access to the erased version.

impl Exponential for Expr<V2<f32>>

fn pow(&self, p: impl Into<Self>) -> Self

fn exp(&self) -> Self

fn exp2(&self) -> Self

fn log(&self) -> Self

fn log2(&self) -> Self

fn sqrt(&self) -> Self

fn isqrt(&self) -> Self

impl Exponential for Expr<V3<f32>>

fn pow(&self, p: impl Into<Self>) -> Self

fn exp(&self) -> Self

fn exp2(&self) -> Self

fn log(&self) -> Self

fn log2(&self) -> Self

fn sqrt(&self) -> Self

fn isqrt(&self) -> Self

impl Exponential for Expr<V4<f32>>

fn pow(&self, p: impl Into<Self>) -> Self

fn exp(&self) -> Self

fn exp2(&self) -> Self

fn log(&self) -> Self

fn log2(&self) -> Self

fn sqrt(&self) -> Self

fn isqrt(&self) -> Self

impl Exponential for Expr<f32>

fn pow(&self, p: impl Into<Self>) -> Self

fn exp(&self) -> Self

fn exp2(&self) -> Self

fn log(&self) -> Self

fn log2(&self) -> Self

fn sqrt(&self) -> Self

fn isqrt(&self) -> Self

impl Floating for Expr<V2<f32>>

fn floor(&self) -> Self

fn trunc(&self) -> Self

fn round(&self) -> Self

fn ceil(&self) -> Self

fn fract(&self) -> Self

impl Floating for Expr<V3<f32>>

fn floor(&self) -> Self

fn trunc(&self) -> Self

fn round(&self) -> Self

fn ceil(&self) -> Self

fn fract(&self) -> Self

impl Floating for Expr<V4<f32>>

fn floor(&self) -> Self

fn trunc(&self) -> Self

fn round(&self) -> Self

fn ceil(&self) -> Self

fn fract(&self) -> Self

impl Floating for Expr<f32>

fn floor(&self) -> Self

fn trunc(&self) -> Self

fn round(&self) -> Self

fn ceil(&self) -> Self

fn fract(&self) -> Self

impl FloatingExt for Expr<V2<f32>>

type BoolExpr = Expr<V2<bool>>

fn is_nan(self) -> Self::BoolExpr

fn is_inf(self) -> Self::BoolExpr

impl FloatingExt for Expr<V3<f32>>

type BoolExpr = Expr<V3<bool>>

fn is_nan(self) -> Self::BoolExpr

fn is_inf(self) -> Self::BoolExpr

impl FloatingExt for Expr<V4<f32>>

type BoolExpr = Expr<V4<bool>>

fn is_nan(self) -> Self::BoolExpr

fn is_inf(self) -> Self::BoolExpr

impl FloatingExt for Expr<f32>

type BoolExpr = Expr<bool>

fn is_nan(self) -> Self::BoolExpr

fn is_inf(self) -> Self::BoolExpr

impl<'a, T, const N: usize> From<&'a [Expr<T>; N]> for Expr<[T; N]> where
    Expr<T>: From<T>,
    T: ToType, 

fn from(array: &'a [Expr<T>; N]) -> Self

Converts to this type from the input type.

impl<'a, T, const N: usize> From<&'a [T; N]> for Expr<[T; N]> where
    Expr<T>: From<T>,
    T: Clone + ToType, 

fn from(array: &'a [T; N]) -> Self

Converts to this type from the input type.

impl<'a, T> From<&'a Var<T>> for Expr<T> where
    T: ?Sized, 

fn from(v: &'a Var<T>) -> Self

Converts to this type from the input type.

impl<T, const N: usize> From<[Expr<T>; N]> for Expr<[T; N]> where
    Expr<T>: From<T>,
    T: ToType, 

fn from(array: [Expr<T>; N]) -> Self

Converts to this type from the input type.

impl<T, const N: usize> From<[T; N]> for Expr<[T; N]> where
    Expr<T>: From<T>,
    T: Clone + ToType, 

fn from(array: [T; N]) -> Self

Converts to this type from the input type.

impl<T> From<Expr<T>> for Return where
    T: ToType, 

fn from(expr: Expr<T>) -> Self

Converts to this type from the input type.

impl From<Matrix<[[f32; 2]; 2]>> for Expr<Matrix<[[f32; 2]; 2]>>

fn from(matrix: Matrix<[[f32; 2]; 2]>) -> Self

Converts to this type from the input type.

impl From<Matrix<[[f32; 3]; 3]>> for Expr<Matrix<[[f32; 3]; 3]>>

fn from(matrix: Matrix<[[f32; 3]; 3]>) -> Self

Converts to this type from the input type.

impl From<Matrix<[[f32; 4]; 4]>> for Expr<Matrix<[[f32; 4]; 4]>>

fn from(matrix: Matrix<[[f32; 4]; 4]>) -> Self

Converts to this type from the input type.

impl From<V2<bool>> for Expr<V2<bool>>

fn from(a: V2<bool>) -> Self

Converts to this type from the input type.

impl From<V2<f32>> for Expr<V2<f32>>

fn from(a: V2<f32>) -> Self

Converts to this type from the input type.

impl From<V2<i32>> for Expr<V2<i32>>

fn from(a: V2<i32>) -> Self

Converts to this type from the input type.

impl From<V2<u32>> for Expr<V2<u32>>

fn from(a: V2<u32>) -> Self

Converts to this type from the input type.

impl From<V3<bool>> for Expr<V3<bool>>

fn from(a: V3<bool>) -> Self

Converts to this type from the input type.

impl From<V3<f32>> for Expr<V3<f32>>

fn from(a: V3<f32>) -> Self

Converts to this type from the input type.

impl From<V3<i32>> for Expr<V3<i32>>

fn from(a: V3<i32>) -> Self

Converts to this type from the input type.

impl From<V3<u32>> for Expr<V3<u32>>

fn from(a: V3<u32>) -> Self

Converts to this type from the input type.

impl From<V4<bool>> for Expr<V4<bool>>

fn from(a: V4<bool>) -> Self

Converts to this type from the input type.

impl From<V4<f32>> for Expr<V4<f32>>

fn from(a: V4<f32>) -> Self

Converts to this type from the input type.

impl From<V4<i32>> for Expr<V4<i32>>

fn from(a: V4<i32>) -> Self

Converts to this type from the input type.

impl From<V4<u32>> for Expr<V4<u32>>

fn from(a: V4<u32>) -> Self

Converts to this type from the input type.

impl<T> From<Var<T>> for Expr<T> where
    T: ?Sized, 

fn from(v: Var<T>) -> Self

Converts to this type from the input type.

impl From<bool> for Expr<bool>

fn from(a: bool) -> Self

Converts to this type from the input type.

impl From<f32> for Expr<f32>

fn from(a: f32) -> Self

Converts to this type from the input type.

impl From<i32> for Expr<i32>

fn from(a: i32) -> Self

Converts to this type from the input type.

impl From<u32> for Expr<u32>

fn from(a: u32) -> Self

Converts to this type from the input type.

impl Geometry for Expr<V2<f32>>

type LengthExpr = Expr<f32>

fn length(self) -> Self::LengthExpr

fn distance(self, other: Self) -> Self::LengthExpr

fn dot(self, other: Self) -> Self::LengthExpr

fn cross(self, other: Self) -> Self

fn normalize(self) -> Self

fn face_forward(self, normal: Self, reference: Self) -> Self

fn reflect(self, normal: Self) -> Self

fn refract(self, normal: Self, eta: Expr<f32>) -> Self

impl Geometry for Expr<V3<f32>>

type LengthExpr = Expr<f32>

fn length(self) -> Self::LengthExpr

fn distance(self, other: Self) -> Self::LengthExpr

fn dot(self, other: Self) -> Self::LengthExpr

fn cross(self, other: Self) -> Self

fn normalize(self) -> Self

fn face_forward(self, normal: Self, reference: Self) -> Self

fn reflect(self, normal: Self) -> Self

fn refract(self, normal: Self, eta: Expr<f32>) -> Self

impl Geometry for Expr<V4<f32>>

type LengthExpr = Expr<f32>

fn length(self) -> Self::LengthExpr

fn distance(self, other: Self) -> Self::LengthExpr

fn dot(self, other: Self) -> Self::LengthExpr

fn cross(self, other: Self) -> Self

fn normalize(self) -> Self

fn face_forward(self, normal: Self, reference: Self) -> Self

fn reflect(self, normal: Self) -> Self

fn refract(self, normal: Self, eta: Expr<f32>) -> Self

impl<T> HasW for Expr<V4<T>>

type Output = Expr<T>

fn w(&self) -> Self::Output

fn a(&self) -> Self::Output

impl<T> HasX for Expr<V2<T>>

type Output = Expr<T>

fn x(&self) -> Self::Output

fn r(&self) -> Self::Output

impl<T> HasX for Expr<V3<T>>

type Output = Expr<T>

fn x(&self) -> Self::Output

fn r(&self) -> Self::Output

impl<T> HasX for Expr<V4<T>>

type Output = Expr<T>

fn x(&self) -> Self::Output

fn r(&self) -> Self::Output

impl<T> HasY for Expr<V2<T>>

type Output = Expr<T>

fn y(&self) -> Self::Output

fn g(&self) -> Self::Output

impl<T> HasY for Expr<V3<T>>

type Output = Expr<T>

fn y(&self) -> Self::Output

fn g(&self) -> Self::Output

impl<T> HasY for Expr<V4<T>>

type Output = Expr<T>

fn y(&self) -> Self::Output

fn g(&self) -> Self::Output

impl<T> HasZ for Expr<V3<T>>

type Output = Expr<T>

fn z(&self) -> Self::Output

fn b(&self) -> Self::Output

impl<T> HasZ for Expr<V4<T>>

type Output = Expr<T>

fn z(&self) -> Self::Output

fn b(&self) -> Self::Output

impl Mix<Expr<V2<f32>>> for Expr<V2<f32>>

fn mix(self, y: Self, a: Expr<V2<f32>>) -> Self

fn step(self, edge: Expr<V2<f32>>) -> Self

fn smooth_step(self, edge_a: Expr<V2<f32>>, edge_b: Expr<V2<f32>>) -> Self

impl Mix<Expr<V3<f32>>> for Expr<V3<f32>>

fn mix(self, y: Self, a: Expr<V3<f32>>) -> Self

fn step(self, edge: Expr<V3<f32>>) -> Self

fn smooth_step(self, edge_a: Expr<V3<f32>>, edge_b: Expr<V3<f32>>) -> Self

impl Mix<Expr<V4<f32>>> for Expr<V4<f32>>

fn mix(self, y: Self, a: Expr<V4<f32>>) -> Self

fn step(self, edge: Expr<V4<f32>>) -> Self

fn smooth_step(self, edge_a: Expr<V4<f32>>, edge_b: Expr<V4<f32>>) -> Self

impl Mix<Expr<f32>> for Expr<V2<f32>>

fn mix(self, y: Self, a: Expr<f32>) -> Self

fn step(self, edge: Expr<f32>) -> Self

fn smooth_step(self, edge_a: Expr<f32>, edge_b: Expr<f32>) -> Self

impl Mix<Expr<f32>> for Expr<V3<f32>>

fn mix(self, y: Self, a: Expr<f32>) -> Self

fn step(self, edge: Expr<f32>) -> Self

fn smooth_step(self, edge_a: Expr<f32>, edge_b: Expr<f32>) -> Self

impl Mix<Expr<f32>> for Expr<V4<f32>>

fn mix(self, y: Self, a: Expr<f32>) -> Self

fn step(self, edge: Expr<f32>) -> Self

fn smooth_step(self, edge_a: Expr<f32>, edge_b: Expr<f32>) -> Self

impl Mix<Expr<f32>> for Expr<f32>

fn mix(self, y: Self, a: Expr<f32>) -> Self

fn step(self, edge: Expr<f32>) -> Self

fn smooth_step(self, edge_a: Expr<f32>, edge_b: Expr<f32>) -> Self

impl<'a> Mul<Expr<Matrix<[[f32; 2]; 2]>>> for Expr<M22>

type Output = Expr<Matrix<[[f32; 2]; 2]>>

The resulting type after applying the * operator.

fn mul(self, rhs: Expr<M22>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Expr<Matrix<[[f32; 2]; 2]>>> for Expr<V2<f32>>

type Output = Expr<Matrix<[[f32; 2]; 2]>>

The resulting type after applying the * operator.

fn mul(self, rhs: Expr<M22>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Expr<Matrix<[[f32; 3]; 3]>>> for Expr<M33>

type Output = Expr<Matrix<[[f32; 3]; 3]>>

The resulting type after applying the * operator.

fn mul(self, rhs: Expr<M33>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Expr<Matrix<[[f32; 3]; 3]>>> for Expr<V3<f32>>

type Output = Expr<Matrix<[[f32; 3]; 3]>>

The resulting type after applying the * operator.

fn mul(self, rhs: Expr<M33>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Expr<Matrix<[[f32; 4]; 4]>>> for Expr<M44>

type Output = Expr<Matrix<[[f32; 4]; 4]>>

The resulting type after applying the * operator.

fn mul(self, rhs: Expr<M44>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Expr<Matrix<[[f32; 4]; 4]>>> for Expr<V4<f32>>

type Output = Expr<Matrix<[[f32; 4]; 4]>>

The resulting type after applying the * operator.

fn mul(self, rhs: Expr<M44>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Expr<V2<f32>>> for Expr<M22>

type Output = Expr<V2<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Expr<V2<f32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Expr<V2<f32>>> for Expr<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Expr<V2<f32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Expr<V2<i32>>> for Expr<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Expr<V2<i32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Expr<V2<u32>>> for Expr<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Expr<V2<u32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Expr<V3<f32>>> for Expr<M33>

type Output = Expr<V3<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Expr<V3<f32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Expr<V3<f32>>> for Expr<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Expr<V3<f32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Expr<V3<i32>>> for Expr<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Expr<V3<i32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Expr<V3<u32>>> for Expr<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Expr<V3<u32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Expr<V4<f32>>> for Expr<M44>

type Output = Expr<V4<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Expr<V4<f32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Expr<V4<f32>>> for Expr<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Expr<V4<f32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Expr<V4<i32>>> for Expr<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Expr<V4<i32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Expr<V4<u32>>> for Expr<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Expr<V4<u32>>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Expr<f32>> for Expr<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Expr<f32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Expr<f32>> for Expr<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Expr<f32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Expr<f32>> for Expr<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Expr<f32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Expr<f32>> for Expr<f32>

type Output = Expr<f32>

The resulting type after applying the * operator.

fn mul(self, rhs: Expr<f32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Expr<i32>> for Expr<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Expr<i32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Expr<i32>> for Expr<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Expr<i32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Expr<i32>> for Expr<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Expr<i32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Expr<i32>> for Expr<i32>

type Output = Expr<i32>

The resulting type after applying the * operator.

fn mul(self, rhs: Expr<i32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Expr<u32>> for Expr<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Expr<u32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Expr<u32>> for Expr<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Expr<u32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Expr<u32>> for Expr<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the * operator.

fn mul(self, rhs: Expr<u32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Expr<u32>> for Expr<u32>

type Output = Expr<u32>

The resulting type after applying the * operator.

fn mul(self, rhs: Expr<u32>) -> Self::Output

Performs the * operation.

impl Neg for Expr<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl Neg for Expr<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl Neg for Expr<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl Neg for Expr<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl Neg for Expr<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl Neg for Expr<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl Neg for Expr<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl Neg for Expr<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl Neg for Expr<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl Neg for Expr<f32>

type Output = Expr<f32>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl Neg for Expr<i32>

type Output = Expr<i32>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl Neg for Expr<u32>

type Output = Expr<u32>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl Not for Expr<V2<bool>>

type Output = Expr<V2<bool>>

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl Not for Expr<V3<bool>>

type Output = Expr<V3<bool>>

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl Not for Expr<V4<bool>>

type Output = Expr<V4<bool>>

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl Not for Expr<bool>

type Output = Expr<bool>

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl Relative for Expr<V2<f32>>

fn abs(&self) -> Self

fn sign(&self) -> Self

impl Relative for Expr<V2<i32>>

fn abs(&self) -> Self

fn sign(&self) -> Self

impl Relative for Expr<V3<f32>>

fn abs(&self) -> Self

fn sign(&self) -> Self

impl Relative for Expr<V3<i32>>

fn abs(&self) -> Self

fn sign(&self) -> Self

impl Relative for Expr<V4<f32>>

fn abs(&self) -> Self

fn sign(&self) -> Self

impl Relative for Expr<V4<i32>>

fn abs(&self) -> Self

fn sign(&self) -> Self

impl Relative for Expr<f32>

fn abs(&self) -> Self

fn sign(&self) -> Self

impl Relative for Expr<i32>

fn abs(&self) -> Self

fn sign(&self) -> Self

impl<'a> Rem<Expr<V2<f32>>> for Expr<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the % operator.

fn rem(self, rhs: Expr<V2<f32>>) -> Self::Output

Performs the % operation.

impl<'a> Rem<Expr<V3<f32>>> for Expr<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the % operator.

fn rem(self, rhs: Expr<V3<f32>>) -> Self::Output

Performs the % operation.

impl<'a> Rem<Expr<V4<f32>>> for Expr<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the % operator.

fn rem(self, rhs: Expr<V4<f32>>) -> Self::Output

Performs the % operation.

impl<'a> Rem<Expr<f32>> for Expr<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the % operator.

fn rem(self, rhs: Expr<f32>) -> Self::Output

Performs the % operation.

impl<'a> Rem<Expr<f32>> for Expr<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the % operator.

fn rem(self, rhs: Expr<f32>) -> Self::Output

Performs the % operation.

impl<'a> Rem<Expr<f32>> for Expr<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the % operator.

fn rem(self, rhs: Expr<f32>) -> Self::Output

Performs the % operation.

impl<'a> Rem<Expr<f32>> for Expr<f32>

type Output = Expr<f32>

The resulting type after applying the % operator.

fn rem(self, rhs: Expr<f32>) -> Self::Output

Performs the % operation.

impl Shl<Expr<u32>> for Expr<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the << operator.

fn shl(self, rhs: Expr<u32>) -> Self::Output

Performs the << operation.

impl Shl<Expr<u32>> for Expr<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the << operator.

fn shl(self, rhs: Expr<u32>) -> Self::Output

Performs the << operation.

impl Shl<Expr<u32>> for Expr<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the << operator.

fn shl(self, rhs: Expr<u32>) -> Self::Output

Performs the << operation.

impl Shl<Expr<u32>> for Expr<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the << operator.

fn shl(self, rhs: Expr<u32>) -> Self::Output

Performs the << operation.

impl Shl<Expr<u32>> for Expr<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the << operator.

fn shl(self, rhs: Expr<u32>) -> Self::Output

Performs the << operation.

impl Shl<Expr<u32>> for Expr<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the << operator.

fn shl(self, rhs: Expr<u32>) -> Self::Output

Performs the << operation.

impl Shl<Expr<u32>> for Expr<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the << operator.

fn shl(self, rhs: Expr<u32>) -> Self::Output

Performs the << operation.

impl Shl<Expr<u32>> for Expr<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the << operator.

fn shl(self, rhs: Expr<u32>) -> Self::Output

Performs the << operation.

impl Shl<Expr<u32>> for Expr<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the << operator.

fn shl(self, rhs: Expr<u32>) -> Self::Output

Performs the << operation.

impl Shl<Expr<u32>> for Expr<f32>

type Output = Expr<f32>

The resulting type after applying the << operator.

fn shl(self, rhs: Expr<u32>) -> Self::Output

Performs the << operation.

impl Shl<Expr<u32>> for Expr<i32>

type Output = Expr<i32>

The resulting type after applying the << operator.

fn shl(self, rhs: Expr<u32>) -> Self::Output

Performs the << operation.

impl Shl<Expr<u32>> for Expr<u32>

type Output = Expr<u32>

The resulting type after applying the << operator.

fn shl(self, rhs: Expr<u32>) -> Self::Output

Performs the << operation.

impl Shr<Expr<u32>> for Expr<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the >> operator.

fn shr(self, rhs: Expr<u32>) -> Self::Output

Performs the >> operation.

impl Shr<Expr<u32>> for Expr<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the >> operator.

fn shr(self, rhs: Expr<u32>) -> Self::Output

Performs the >> operation.

impl Shr<Expr<u32>> for Expr<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the >> operator.

fn shr(self, rhs: Expr<u32>) -> Self::Output

Performs the >> operation.

impl Shr<Expr<u32>> for Expr<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the >> operator.

fn shr(self, rhs: Expr<u32>) -> Self::Output

Performs the >> operation.

impl Shr<Expr<u32>> for Expr<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the >> operator.

fn shr(self, rhs: Expr<u32>) -> Self::Output

Performs the >> operation.

impl Shr<Expr<u32>> for Expr<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the >> operator.

fn shr(self, rhs: Expr<u32>) -> Self::Output

Performs the >> operation.

impl Shr<Expr<u32>> for Expr<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the >> operator.

fn shr(self, rhs: Expr<u32>) -> Self::Output

Performs the >> operation.

impl Shr<Expr<u32>> for Expr<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the >> operator.

fn shr(self, rhs: Expr<u32>) -> Self::Output

Performs the >> operation.

impl Shr<Expr<u32>> for Expr<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the >> operator.

fn shr(self, rhs: Expr<u32>) -> Self::Output

Performs the >> operation.

impl Shr<Expr<u32>> for Expr<f32>

type Output = Expr<f32>

The resulting type after applying the >> operator.

fn shr(self, rhs: Expr<u32>) -> Self::Output

Performs the >> operation.

impl Shr<Expr<u32>> for Expr<i32>

type Output = Expr<i32>

The resulting type after applying the >> operator.

fn shr(self, rhs: Expr<u32>) -> Self::Output

Performs the >> operation.

impl Shr<Expr<u32>> for Expr<u32>

type Output = Expr<u32>

The resulting type after applying the >> operator.

fn shr(self, rhs: Expr<u32>) -> Self::Output

Performs the >> operation.

impl<'a> Sub<Expr<V2<f32>>> for Expr<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the - operator.

fn sub(self, rhs: Expr<V2<f32>>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Expr<V2<i32>>> for Expr<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the - operator.

fn sub(self, rhs: Expr<V2<i32>>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Expr<V2<u32>>> for Expr<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the - operator.

fn sub(self, rhs: Expr<V2<u32>>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Expr<V3<f32>>> for Expr<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the - operator.

fn sub(self, rhs: Expr<V3<f32>>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Expr<V3<i32>>> for Expr<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the - operator.

fn sub(self, rhs: Expr<V3<i32>>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Expr<V3<u32>>> for Expr<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the - operator.

fn sub(self, rhs: Expr<V3<u32>>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Expr<V4<f32>>> for Expr<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the - operator.

fn sub(self, rhs: Expr<V4<f32>>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Expr<V4<i32>>> for Expr<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the - operator.

fn sub(self, rhs: Expr<V4<i32>>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Expr<V4<u32>>> for Expr<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the - operator.

fn sub(self, rhs: Expr<V4<u32>>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Expr<f32>> for Expr<V2<f32>>

type Output = Expr<V2<f32>>

The resulting type after applying the - operator.

fn sub(self, rhs: Expr<f32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Expr<f32>> for Expr<V3<f32>>

type Output = Expr<V3<f32>>

The resulting type after applying the - operator.

fn sub(self, rhs: Expr<f32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Expr<f32>> for Expr<V4<f32>>

type Output = Expr<V4<f32>>

The resulting type after applying the - operator.

fn sub(self, rhs: Expr<f32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Expr<f32>> for Expr<f32>

type Output = Expr<f32>

The resulting type after applying the - operator.

fn sub(self, rhs: Expr<f32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Expr<i32>> for Expr<V2<i32>>

type Output = Expr<V2<i32>>

The resulting type after applying the - operator.

fn sub(self, rhs: Expr<i32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Expr<i32>> for Expr<V3<i32>>

type Output = Expr<V3<i32>>

The resulting type after applying the - operator.

fn sub(self, rhs: Expr<i32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Expr<i32>> for Expr<V4<i32>>

type Output = Expr<V4<i32>>

The resulting type after applying the - operator.

fn sub(self, rhs: Expr<i32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Expr<i32>> for Expr<i32>

type Output = Expr<i32>

The resulting type after applying the - operator.

fn sub(self, rhs: Expr<i32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Expr<u32>> for Expr<V2<u32>>

type Output = Expr<V2<u32>>

The resulting type after applying the - operator.

fn sub(self, rhs: Expr<u32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Expr<u32>> for Expr<V3<u32>>

type Output = Expr<V3<u32>>

The resulting type after applying the - operator.

fn sub(self, rhs: Expr<u32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Expr<u32>> for Expr<V4<u32>>

type Output = Expr<V4<u32>>

The resulting type after applying the - operator.

fn sub(self, rhs: Expr<u32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Expr<u32>> for Expr<u32>

type Output = Expr<u32>

The resulting type after applying the - operator.

fn sub(self, rhs: Expr<u32>) -> Self::Output

Performs the - operation.

impl<T> Swizzlable<[SwizzleSelector; 2]> for Expr<V2<T>>

type Output = Expr<V2<T>>

fn swizzle(&self, [x, y]: [SwizzleSelector; 2]) -> Self::Output

impl<T> Swizzlable<[SwizzleSelector; 2]> for Expr<V3<T>>

type Output = Expr<V2<T>>

fn swizzle(&self, [x, y]: [SwizzleSelector; 2]) -> Self::Output

impl<T> Swizzlable<[SwizzleSelector; 2]> for Expr<V4<T>>

type Output = Expr<V2<T>>

fn swizzle(&self, [x, y]: [SwizzleSelector; 2]) -> Self::Output

impl<T> Swizzlable<[SwizzleSelector; 3]> for Expr<V3<T>>

type Output = Expr<V3<T>>

fn swizzle(&self, [x, y, z]: [SwizzleSelector; 3]) -> Self::Output

impl<T> Swizzlable<[SwizzleSelector; 3]> for Expr<V4<T>>

type Output = Expr<V3<T>>

fn swizzle(&self, [x, y, z]: [SwizzleSelector; 3]) -> Self::Output

impl<T> Swizzlable<[SwizzleSelector; 4]> for Expr<V4<T>>

type Output = Expr<V4<T>>

fn swizzle(&self, [x, y, z, w]: [SwizzleSelector; 4]) -> Self::Output

impl<T> Swizzlable<SwizzleSelector> for Expr<V2<T>>

type Output = Expr<T>

fn swizzle(&self, x: SwizzleSelector) -> Self::Output

impl<T> Swizzlable<SwizzleSelector> for Expr<V3<T>>

type Output = Expr<T>

fn swizzle(&self, x: SwizzleSelector) -> Self::Output

impl<T> Swizzlable<SwizzleSelector> for Expr<V4<T>>

type Output = Expr<T>

fn swizzle(&self, x: SwizzleSelector) -> Self::Output

impl<T> ToPrimType for Expr<T> where
    T: ToPrimType, 

const PRIM_TYPE: PrimType = T::PRIM_TYPE

Mapped primitive type.

impl Trigonometry for Expr<V2<f32>>

fn radians(&self) -> Self

fn degrees(&self) -> Self

fn sin(&self) -> Self

fn cos(&self) -> Self

fn tan(&self) -> Self

fn asin(&self) -> Self

fn acos(&self) -> Self

fn atan(&self) -> Self

fn sinh(&self) -> Self

fn cosh(&self) -> Self

fn tanh(&self) -> Self

fn asinh(&self) -> Self

fn acosh(&self) -> Self

fn atanh(&self) -> Self

impl Trigonometry for Expr<V3<f32>>

fn radians(&self) -> Self

fn degrees(&self) -> Self

fn sin(&self) -> Self

fn cos(&self) -> Self

fn tan(&self) -> Self

fn asin(&self) -> Self

fn acos(&self) -> Self

fn atan(&self) -> Self

fn sinh(&self) -> Self

fn cosh(&self) -> Self

fn tanh(&self) -> Self

fn asinh(&self) -> Self

fn acosh(&self) -> Self

fn atanh(&self) -> Self

impl Trigonometry for Expr<V4<f32>>

fn radians(&self) -> Self

fn degrees(&self) -> Self

fn sin(&self) -> Self

fn cos(&self) -> Self

fn tan(&self) -> Self

fn asin(&self) -> Self

fn acos(&self) -> Self

fn atan(&self) -> Self

fn sinh(&self) -> Self

fn cosh(&self) -> Self

fn tanh(&self) -> Self

fn asinh(&self) -> Self

fn acosh(&self) -> Self

fn atanh(&self) -> Self

impl Trigonometry for Expr<f32>

fn radians(&self) -> Self

fn degrees(&self) -> Self

fn sin(&self) -> Self

fn cos(&self) -> Self

fn tan(&self) -> Self

fn asin(&self) -> Self

fn acos(&self) -> Self

fn atan(&self) -> Self

fn sinh(&self) -> Self

fn cosh(&self) -> Self

fn tanh(&self) -> Self

fn asinh(&self) -> Self

fn acosh(&self) -> Self

fn atanh(&self) -> Self

impl<T> Vec2<(Expr<T>, Expr<T>)> for Expr<V2<T>>

fn vec2(args: (Expr<T>, Expr<T>)) -> Self

Make a V2 from A.

impl<T> Vec3<(Expr<T>, Expr<T>, Expr<T>)> for Expr<V3<T>>

fn vec3(args: (Expr<T>, Expr<T>, Expr<T>)) -> Self

Make a V3 from A.

impl<T> Vec3<(Expr<V2<T>>, Expr<T>)> for Expr<V3<T>>

fn vec3(args: (Expr<V2<T>>, Expr<T>)) -> Self

Make a V3 from A.

impl<'a, T> Vec4<(Expr<T>, Expr<T>, Expr<T>, Expr<T>)> for Expr<V4<T>>

fn vec4(args: (Expr<T>, Expr<T>, Expr<T>, Expr<T>)) -> Self

Make a V4 from A.

impl<'a, T> Vec4<(Expr<V2<T>>, Expr<T>, Expr<T>)> for Expr<V4<T>>

fn vec4(args: (Expr<V2<T>>, Expr<T>, Expr<T>)) -> Self

Make a V4 from A.

impl<T> Vec4<(Expr<V2<T>>, Expr<V2<T>>)> for Expr<V4<T>>

fn vec4(args: (Expr<V2<T>>, Expr<V2<T>>)) -> Self

Make a V4 from A.

impl<T> Vec4<(Expr<V3<T>>, Expr<T>)> for Expr<V4<T>>

fn vec4(args: (Expr<V3<T>>, Expr<T>)) -> Self

Make a V4 from A.