Enum UnaryOperator 

pub enum UnaryOperator {
    Abs,
    Acos,
    Asin,
    Atan,
    All,
    Any,
    Ceil,
    Cos,
    Exp,
    Exp2,
    Floor,
    Fract,
    InvSqrt,
    Length,
    Log,
    Log2,
    Normalize,
    Pack4x8snorm,
    Pack4x8unorm,
    Round,
    Saturate,
    Sign,
    Sin,
    Sqrt,
    Tan,
    Unpack4x8snorm,
    Unpack4x8unorm,
    W,
    X,
    Y,
    Z,
}

Unary operator.

Operator applied to a single operand to produce another value. The type of the operand and the result are not necessarily the same. Valid operand types depend on the operator itself.

Variants

Abs

Absolute value operator.

Return the absolute value of the operand, component-wise for vectors. Only valid for numeric operands.

Acos

Inverse cosine operator.

Return the inverse cosine of the operand, component-wise for vectors. Only valid for floating-point operands.

Asin

Inverse sine operator.

Return the inverse sine of the operand, component-wise for vectors. Only valid for floating-point operands.

Atan

Inverse tangent operator.

Return the inverse tangent of the operand, component-wise for vectors. Only valid for floating-point operands.

All

Logical ALL operator for bool vectors.

Return true if all the components of the bool vector operand are true. Invalid for any other type of operand.

Any

Logical ANY operator for bool vectors.

Return true if any component of the bool vector operand is true. Invalid for any other type of operand.

Ceil

Ceiling operator.

Return the unique integral number k such that k-1 < x <= k, where x is the operand which the operator applies to.

Cos

Cosine operator.

Exp

Natural exponent operator.

Return the natural exponentiation of the operand (e^x), component-wise for vectors.

Exp2

Base-2 exponent operator.

Return two raised to the power of the operand (2^x), component-wise for vectors.

Floor

Floor operator.

Return the unique integral number k such that k <= x < k+1, where x is the operand which the operator applies to.

Fract

Fractional part operator.

Return the fractional part of the operand, which is equal to x - floor(x), component-wise for vectors.

InvSqrt

Inverse square root operator.

Return the inverse square root of the floating-point operand (1.0 / sqrt(x)), component-wise for vectors.

Length

Length operator.

Return the length of a floating point scalar or vector. The “length” of a scalar is taken as its absolute value. The length of a vector is the Euclidian distance sqrt(x^2 + ...) (square root of the sum of the squared components).

The output is always a floating point scalar.

Log

Natural logarithm operator.

Return the natural logarithm of the operand (log(x)), component-wise for vectors.

Log2

Base-2 logarithm operator.

Return the base-2 logarithm of the operand (log2(x)), component-wise for vectors.

Normalize

Vector normalizing operator.

Normalize the given numeric vector. Only valid for numeric vector operands.

Pack4x8snorm

Packing operator from vec4<f32> to u32 (signed normalized).

Convert the four components of a signed normalized floating point vector into a signed integral i8 value in [-128:127], then pack those four values into a single u32. Each vector component should be in [-1:1] before packing; values outside this range are clamped.

Pack4x8unorm

Packing operator from vec4<f32> to u32 (unsigned normalized).

Convert the four components of an unsigned normalized floating point vector into an unsigned integral u8 value in [0:255], then pack those four values into a single u32. Each vector component should be in [0:1] before packing; values outside this range are clamped.

Round

Rounding operator.

Round the given scalar of vector float to the nearest integer, returned as a float value.

Saturate

Saturate operator.

Clamp the value of the operand to the [0:1] range, component-wise for vectors.

Sign

Sign operator.

Return a value representing the sign of a floating point scalar or vector input:

• 1. if the operand is > 0
• 0. if the operand is = 0
• -1. if the operand is < 0

Applies component-wise for vectors.

Sin

Sine operator.

Sqrt

Square root operator.

Return the square root of the floating-point operand, component-wise for vectors.

Tan

Tangent operator.

Unpack4x8snorm

Unpacking operator from u32 to vec4<f32> (signed normalized).

Unpack the u32 into four signed integral i8 value in [-128:127], then convert each value to a signed normalized f32 value in [-1:1].

Unpack4x8unorm

Unpacking operator from u32 to vec4<f32> (unsigned normalized).

Unpack the u32 into four unsigned integral u8 value in [0:255], then convert each value to an unsigned normalized f32 value in [0:1].

W

Get the fourth component of a vector.

This is only valid for vectors of rank 4.

X

Get the first component of a scalar or vector.

For scalar, return the value itself. For vectors, return the first component.

Y

Get the second component of a vector.

Z

Get the third component of a vector.

This is only valid for vectors of rank 3 or more.

Implementations

impl UnaryOperator

pub fn is_functional(&self) -> bool

Check if a unary operator is called via a functional-style call.

Functional-style calls are in the form op(inner), like abs(x) for example, while non-functional ones are in the form inner.op, like v.x for example. This check is used for formatting the WGSL code emitted during evaluation of a binary operation expression.

Trait Implementations

impl Clone for UnaryOperator

fn clone(&self) -> UnaryOperator

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for UnaryOperator

impl Debug for UnaryOperator

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for UnaryOperator

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Enum for UnaryOperator

fn field(&self, __name_param: &str) -> Option<&dyn PartialReflect>

Returns a reference to the value of the field (in the current variant) with the given name.

fn field_at(&self, __index_param: usize) -> Option<&dyn PartialReflect>

Returns a reference to the value of the field (in the current variant) at the given index.

fn field_mut(&mut self, __name_param: &str) -> Option<&mut dyn PartialReflect>

Returns a mutable reference to the value of the field (in the current variant) with the given name.

fn field_at_mut( &mut self, __index_param: usize, ) -> Option<&mut dyn PartialReflect>

Returns a mutable reference to the value of the field (in the current variant) at the given index.

fn index_of(&self, __name_param: &str) -> Option<usize>

Returns the index of the field (in the current variant) with the given name.

fn name_at(&self, __index_param: usize) -> Option<&str>

Returns the name of the field (in the current variant) with the given index.

fn iter_fields(&self) -> VariantFieldIter<'_>

Returns an iterator over the values of the current variant’s fields.

fn field_len(&self) -> usize

Returns the number of fields in the current variant.

fn variant_name(&self) -> &str

The name of the current variant.

fn variant_index(&self) -> usize

The index of the current variant.

fn variant_type(&self) -> VariantType

The type of the current variant.

fn to_dynamic_enum(&self) -> DynamicEnum

Creates a new DynamicEnum from this enum.

fn is_variant(&self, variant_type: VariantType) -> bool

Returns true if the current variant’s type matches the given one.

fn variant_path(&self) -> String

Returns the full path to the current variant.

fn get_represented_enum_info(&self) -> Option<&'static EnumInfo>

Will return None if TypeInfo is not available.

impl Eq for UnaryOperator

impl FromReflect for UnaryOperator

fn from_reflect(__param0: &dyn PartialReflect) -> Option<Self>

Constructs a concrete instance of Self from a reflected value.

fn take_from_reflect( reflect: Box<dyn PartialReflect>, ) -> Result<Self, Box<dyn PartialReflect>>

Attempts to downcast the given value to Self using, constructing the value using from_reflect if that fails.

impl GetTypeRegistration for UnaryOperator

fn get_type_registration() -> TypeRegistration

Returns the default TypeRegistration for this type.

fn register_type_dependencies(registry: &mut TypeRegistry)

Registers other types needed by this type.

impl Hash for UnaryOperator

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for UnaryOperator

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

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

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

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

impl PartialReflect for UnaryOperator

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

Returns the TypeInfo of the type represented by this value.

fn try_apply( &mut self, __value_param: &dyn PartialReflect, ) -> Result<(), ApplyError>

Tries to apply a reflected value to this value.

fn reflect_kind(&self) -> ReflectKind

Returns a zero-sized enumeration of “kinds” of type.

fn reflect_ref(&self) -> ReflectRef<'_>

Returns an immutable enumeration of “kinds” of type.

fn reflect_mut(&mut self) -> ReflectMut<'_>

Returns a mutable enumeration of “kinds” of type.

fn reflect_owned(self: Box<Self>) -> ReflectOwned

Returns an owned enumeration of “kinds” of type.

fn try_into_reflect( self: Box<Self>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

Attempts to cast this type to a boxed, fully-reflected value.

fn try_as_reflect(&self) -> Option<&dyn Reflect>

Attempts to cast this type to a fully-reflected value.

fn try_as_reflect_mut(&mut self) -> Option<&mut dyn Reflect>

Attempts to cast this type to a mutable, fully-reflected value.

fn into_partial_reflect(self: Box<Self>) -> Box<dyn PartialReflect>

Casts this type to a boxed, reflected value.

fn as_partial_reflect(&self) -> &dyn PartialReflect

Casts this type to a reflected value.

fn as_partial_reflect_mut(&mut self) -> &mut dyn PartialReflect

Casts this type to a mutable, reflected value.

fn reflect_hash(&self) -> Option<u64>

Returns a hash of the value (which includes the type).

fn reflect_partial_eq(&self, value: &dyn PartialReflect) -> Option<bool>

Returns a “partial equality” comparison result.

fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

Attempts to clone Self using reflection.

fn apply(&mut self, value: &(dyn PartialReflect + 'static))

Applies a reflected value to this value.

fn to_dynamic(&self) -> Box<dyn PartialReflect>

Converts this reflected value into its dynamic representation based on its kind.

fn reflect_clone_and_take<T>(&self) -> Result<T, ReflectCloneError>

where T: 'static, Self: Sized + TypePath,

For a type implementing PartialReflect, combines reflect_clone and take in a useful fashion, automatically constructing an appropriate ReflectCloneError if the downcast fails.

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

Debug formatter for the value.

fn is_dynamic(&self) -> bool

Indicates whether or not this type is a dynamic type.

impl Reflect for UnaryOperator

fn into_any(self: Box<Self>) -> Box<dyn Any>

Returns the value as a Box<dyn Any>.

fn as_any(&self) -> &dyn Any

Returns the value as a &dyn Any.

fn as_any_mut(&mut self) -> &mut dyn Any

Returns the value as a &mut dyn Any.

fn into_reflect(self: Box<Self>) -> Box<dyn Reflect>

Casts this type to a boxed, fully-reflected value.

fn as_reflect(&self) -> &dyn Reflect

Casts this type to a fully-reflected value.

fn as_reflect_mut(&mut self) -> &mut dyn Reflect

Casts this type to a mutable, fully-reflected value.

fn set(&mut self, value: Box<dyn Reflect>) -> Result<(), Box<dyn Reflect>>

Performs a type-checked assignment of a reflected value to this value.

impl Serialize for UnaryOperator

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for UnaryOperator

impl ToWgslString for UnaryOperator

fn to_wgsl_string(&self) -> String

Convert an object to a string representing its WGSL code.

impl TypePath for UnaryOperator

fn type_path() -> &'static str

Returns the fully qualified path of the underlying type.

fn short_type_path() -> &'static str

Returns a short, pretty-print enabled path to the type.

fn type_ident() -> Option<&'static str>

Returns the name of the type, or None if it is anonymous.

fn crate_name() -> Option<&'static str>

Returns the name of the crate the type is in, or None if it is anonymous.

fn module_path() -> Option<&'static str>

Returns the path to the module the type is in, or None if it is anonymous.

impl Typed for UnaryOperator

fn type_info() -> &'static TypeInfo

Returns the compile-time info for the underlying type.