Enum StencilOp 

pub enum StencilOp {
    Keep,
    Zero,
    Replace,
    IncrementClamp,
    DecrementClamp,
    Invert,
    IncrementWrap,
    DecrementWrap,
}

Operations performed on current stencil value when comparison test passes or fails.

Variants

Keep

Default value

Zero

Replace

IncrementClamp

DecrementClamp

Invert

IncrementWrap

DecrementWrap

Trait Implementations

impl Clone for StencilOp

fn clone(&self) -> StencilOp

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for StencilOp

impl Debug for StencilOp

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for StencilOp

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for StencilOp

impl Hash for StencilOp

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 IoLoad for StencilOp

fn load_own_extensions() -> impl Iterator<Item = &'static str>

Dedicated file extension to load the value. ex png, jpeg for image

fn load_from_bytes_with_own_extension( data: &[u8], path: &str, extension: &str, ) -> Result<Self, IoError>

fn load_from_bytes_with_own_extension_pathless( data: &[u8], extension: &str, ) -> Result<Self, IoErrorKind>

const CAN_BE_LOADED_FROM_TEXT: bool = false

fn load_from_str_with_own_extension( data: &str, path: &str, extension: &str, ) -> Result<Self, IoError>

fn load_from_str_with_own_extension_pathless( data: &str, extension: &str, ) -> Result<Self, IoErrorKind>

fn can_open_own_extension(extension: &str) -> bool

Don’t include the markup language extension like json or ron

fn load_extensions() -> impl Iterator<Item = &'static str>

Also include the markup language extension like json or ron

fn can_open_extension(extension: &str) -> bool

Also include the markup language extension like json or ron

fn load_from<Fs>(path: &str, fs: &mut Fs) -> Result<Self, IoError>

where Fs: IoFsRead,

fn load_from_with_extension<Fs>( path: &str, extension: &str, fs: &mut Fs, ) -> Result<Self, IoError>

where Fs: IoFsRead,

fn load_from_reader<R>(r: R, path: &str) -> Result<Self, IoError>

where R: Read,

Support bytes and str

fn load_from_bytes(data: &[u8], path: &str) -> Result<Self, IoError>

Support bytes and str

fn load_from_bytes_with_extension( data: &[u8], path: &str, extension: &str, ) -> Result<Self, IoError>

Support bytes and str

impl IoSave for StencilOp

fn save_own_extensions() -> impl Iterator<Item = &'static str>

Dedicated file extension to save the value. ex png, jpeg for image

fn save_to_with_own_extension<W, Fs>( &self, path: &str, extension: &str, w: W, fs: &mut Fs, ) -> Result<(), IoError>

where W: Write, Fs: IoFsWrite,

fn save_to_with_own_extension_pathless<W, Fs>( &self, extension: &str, w: W, fs: &mut Fs, ) -> Result<(), IoErrorKind>

where W: Write, Fs: IoFsWrite,

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

When saving, if the extension is missing, the file will use this extension by default

fn can_save_own_extension(extension: &str) -> bool

Don’t include the markup language extension like json or ron

fn save_extensions() -> impl Iterator<Item = &'static str>

Also include the markup language extension like json or ron

fn can_save_extension(extension: &str) -> bool

Also include the markup language extension like json or ron

fn save_to<Fs>(&self, path: &str, fs: &mut Fs) -> Result<(), IoError>

where Fs: IoFsWrite,

fn save_to_with_extension<Fs>( &self, path: &str, extension: &str, fs: &mut Fs, ) -> Result<(), IoError>

where Fs: IoFsWrite,

fn save_with_reader<W, Fs>( &self, path: &str, w: W, fs: &mut Fs, ) -> Result<(), IoError>

where W: Write, Fs: IoFsWrite,

fn save_with_reader_and_extension<W, Fs>( &self, path: &str, extension: &str, w: W, fs: &mut Fs, ) -> Result<(), IoError>

where W: Write, Fs: IoFsWrite,

impl PartialEq for StencilOp

fn eq(&self, other: &StencilOp) -> 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 Serialize for StencilOp

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 StencilOp