Skip to main content

bevy_material/
alpha.rs

1//! Allows configuring a material's transparency behavior.
2
3use bevy_reflect::{std_traits::ReflectDefault, Reflect};
4
5// TODO: add discussion about performance.
6/// Sets how a material's base color alpha channel is used for transparency.
7#[derive(#[automatically_derived]
impl ::core::fmt::Debug for AlphaMode {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        match self {
            AlphaMode::Opaque =>
                ::core::fmt::Formatter::write_str(f, "Opaque"),
            AlphaMode::Mask(__self_0) =>
                ::core::fmt::Formatter::debug_tuple_field1_finish(f, "Mask",
                    &__self_0),
            AlphaMode::Blend => ::core::fmt::Formatter::write_str(f, "Blend"),
            AlphaMode::Premultiplied =>
                ::core::fmt::Formatter::write_str(f, "Premultiplied"),
            AlphaMode::AlphaToCoverage =>
                ::core::fmt::Formatter::write_str(f, "AlphaToCoverage"),
            AlphaMode::Add => ::core::fmt::Formatter::write_str(f, "Add"),
            AlphaMode::Multiply =>
                ::core::fmt::Formatter::write_str(f, "Multiply"),
        }
    }
}Debug, #[automatically_derived]
impl ::core::default::Default for AlphaMode {
    #[inline]
    fn default() -> AlphaMode { Self::Opaque }
}Default, const _: () =
    {
        impl bevy_reflect::GetTypeRegistration for AlphaMode where  {
            fn get_type_registration() -> bevy_reflect::TypeRegistration {
                let mut registration =
                    bevy_reflect::TypeRegistration::of::<Self>();
                registration.insert::<bevy_reflect::ReflectFromPtr>(bevy_reflect::FromType::<Self>::from_type());
                registration.insert::<bevy_reflect::ReflectFromReflect>(bevy_reflect::FromType::<Self>::from_type());
                registration.register_type_data::<ReflectDefault, Self>();
                registration
            }
            #[inline(never)]
            fn register_type_dependencies(registry:
                    &mut bevy_reflect::TypeRegistry) {
                <f32 as
                        bevy_reflect::__macro_exports::RegisterForReflection>::__register(registry);
            }
        }
        impl bevy_reflect::Typed for AlphaMode where  {
            #[inline]
            fn type_info() -> &'static bevy_reflect::TypeInfo {
                static CELL: bevy_reflect::utility::NonGenericTypeInfoCell =
                    bevy_reflect::utility::NonGenericTypeInfoCell::new();
                CELL.get_or_set(||
                        {
                            bevy_reflect::TypeInfo::Enum(bevy_reflect::enums::EnumInfo::new::<Self>(&[bevy_reflect::enums::VariantInfo::Unit(bevy_reflect::enums::UnitVariantInfo::new("Opaque")),
                                                bevy_reflect::enums::VariantInfo::Tuple(bevy_reflect::enums::TupleVariantInfo::new("Mask",
                                                        &[bevy_reflect::UnnamedField::new::<f32>(0usize)])),
                                                bevy_reflect::enums::VariantInfo::Unit(bevy_reflect::enums::UnitVariantInfo::new("Blend")),
                                                bevy_reflect::enums::VariantInfo::Unit(bevy_reflect::enums::UnitVariantInfo::new("Premultiplied")),
                                                bevy_reflect::enums::VariantInfo::Unit(bevy_reflect::enums::UnitVariantInfo::new("AlphaToCoverage")),
                                                bevy_reflect::enums::VariantInfo::Unit(bevy_reflect::enums::UnitVariantInfo::new("Add")),
                                                bevy_reflect::enums::VariantInfo::Unit(bevy_reflect::enums::UnitVariantInfo::new("Multiply"))]))
                        })
            }
        }
        #[allow(deprecated, reason =
        "derives on a deprecated type shouldn't be considered a usage")]
        impl bevy_reflect::TypePath for AlphaMode where  {
            fn type_path() -> &'static str {
                "bevy_material::alpha::AlphaMode"
            }
            fn short_type_path() -> &'static str { "AlphaMode" }
            fn type_ident() -> ::core::option::Option<&'static str> {
                ::core::option::Option::Some("AlphaMode")
            }
            fn crate_name() -> ::core::option::Option<&'static str> {
                ::core::option::Option::Some("bevy_material::alpha".split(':').next().unwrap())
            }
            fn module_path() -> ::core::option::Option<&'static str> {
                ::core::option::Option::Some("bevy_material::alpha")
            }
        }
        impl bevy_reflect::Reflect for AlphaMode where  {
            #[inline]
            fn into_any(self:
                    bevy_reflect::__macro_exports::alloc_utils::Box<Self>)
                ->
                    bevy_reflect::__macro_exports::alloc_utils::Box<dyn ::core::any::Any> {
                self
            }
            #[inline]
            fn as_any(&self) -> &dyn ::core::any::Any { self }
            #[inline]
            fn as_any_mut(&mut self) -> &mut dyn ::core::any::Any { self }
            #[inline]
            fn into_reflect(self:
                    bevy_reflect::__macro_exports::alloc_utils::Box<Self>)
                ->
                    bevy_reflect::__macro_exports::alloc_utils::Box<dyn bevy_reflect::Reflect> {
                self
            }
            #[inline]
            fn as_reflect(&self) -> &dyn bevy_reflect::Reflect { self }
            #[inline]
            fn as_reflect_mut(&mut self) -> &mut dyn bevy_reflect::Reflect {
                self
            }
            #[inline]
            fn set(&mut self,
                value:
                    bevy_reflect::__macro_exports::alloc_utils::Box<dyn bevy_reflect::Reflect>)
                ->
                    ::core::result::Result<(),
                    bevy_reflect::__macro_exports::alloc_utils::Box<dyn bevy_reflect::Reflect>> {
                *self = <dyn bevy_reflect::Reflect>::take(value)?;
                ::core::result::Result::Ok(())
            }
        }
        #[allow(non_upper_case_globals)]
        const _: () =
            {
                static __INVENTORY: ::inventory::Node =
                    ::inventory::Node {
                        value: &{
                                bevy_reflect::__macro_exports::auto_register::AutomaticReflectRegistrations(<AlphaMode
                                        as
                                        bevy_reflect::__macro_exports::auto_register::RegisterForReflection>::__register)
                            },
                        next: ::inventory::__private::UnsafeCell::new(::inventory::__private::Option::None),
                    };
                #[link_section = ".text.startup"]
                unsafe extern "C" fn __ctor() {
                    unsafe {
                        ::inventory::ErasedNode::submit(__INVENTORY.value,
                            &__INVENTORY)
                    }
                }
                #[used]
                #[link_section = ".init_array"]
                static __CTOR: unsafe extern "C" fn() = __ctor;
            };
        impl bevy_reflect::enums::Enum for AlphaMode where  {
            fn field(&self, __name_param: &str)
                -> ::core::option::Option<&dyn bevy_reflect::PartialReflect> {
                match self { _ => ::core::option::Option::None, }
            }
            fn field_at(&self, __index_param: usize)
                -> ::core::option::Option<&dyn bevy_reflect::PartialReflect> {
                match self {
                    AlphaMode::Mask { 0: __value, .. } if
                        __index_param == 0usize =>
                        ::core::option::Option::Some(__value),
                    _ => ::core::option::Option::None,
                }
            }
            fn field_mut(&mut self, __name_param: &str)
                ->
                    ::core::option::Option<&mut dyn bevy_reflect::PartialReflect> {
                match self { _ => ::core::option::Option::None, }
            }
            fn field_at_mut(&mut self, __index_param: usize)
                ->
                    ::core::option::Option<&mut dyn bevy_reflect::PartialReflect> {
                match self {
                    AlphaMode::Mask { 0: __value, .. } if
                        __index_param == 0usize =>
                        ::core::option::Option::Some(__value),
                    _ => ::core::option::Option::None,
                }
            }
            fn index_of(&self, __name_param: &str)
                -> ::core::option::Option<usize> {
                match self { _ => ::core::option::Option::None, }
            }
            fn name_at(&self, __index_param: usize)
                -> ::core::option::Option<&str> {
                match self { _ => ::core::option::Option::None, }
            }
            fn iter_fields(&self) -> bevy_reflect::enums::VariantFieldIter {
                bevy_reflect::enums::VariantFieldIter::new(self)
            }
            #[inline]
            fn field_len(&self) -> usize {
                match self {
                    AlphaMode::Opaque { .. } => 0usize,
                    AlphaMode::Mask { .. } => 1usize,
                    AlphaMode::Blend { .. } => 0usize,
                    AlphaMode::Premultiplied { .. } => 0usize,
                    AlphaMode::AlphaToCoverage { .. } => 0usize,
                    AlphaMode::Add { .. } => 0usize,
                    AlphaMode::Multiply { .. } => 0usize,
                    _ => 0,
                }
            }
            #[inline]
            fn variant_name(&self) -> &str {
                match self {
                    AlphaMode::Opaque { .. } => "Opaque",
                    AlphaMode::Mask { .. } => "Mask",
                    AlphaMode::Blend { .. } => "Blend",
                    AlphaMode::Premultiplied { .. } => "Premultiplied",
                    AlphaMode::AlphaToCoverage { .. } => "AlphaToCoverage",
                    AlphaMode::Add { .. } => "Add",
                    AlphaMode::Multiply { .. } => "Multiply",
                    _ =>
                        ::core::panicking::panic("internal error: entered unreachable code"),
                }
            }
            #[inline]
            fn variant_index(&self) -> usize {
                match self {
                    AlphaMode::Opaque { .. } => 0usize,
                    AlphaMode::Mask { .. } => 1usize,
                    AlphaMode::Blend { .. } => 2usize,
                    AlphaMode::Premultiplied { .. } => 3usize,
                    AlphaMode::AlphaToCoverage { .. } => 4usize,
                    AlphaMode::Add { .. } => 5usize,
                    AlphaMode::Multiply { .. } => 6usize,
                    _ =>
                        ::core::panicking::panic("internal error: entered unreachable code"),
                }
            }
            #[inline]
            fn variant_type(&self) -> bevy_reflect::enums::VariantType {
                match self {
                    AlphaMode::Opaque { .. } =>
                        bevy_reflect::enums::VariantType::Unit,
                    AlphaMode::Mask { .. } =>
                        bevy_reflect::enums::VariantType::Tuple,
                    AlphaMode::Blend { .. } =>
                        bevy_reflect::enums::VariantType::Unit,
                    AlphaMode::Premultiplied { .. } =>
                        bevy_reflect::enums::VariantType::Unit,
                    AlphaMode::AlphaToCoverage { .. } =>
                        bevy_reflect::enums::VariantType::Unit,
                    AlphaMode::Add { .. } =>
                        bevy_reflect::enums::VariantType::Unit,
                    AlphaMode::Multiply { .. } =>
                        bevy_reflect::enums::VariantType::Unit,
                    _ =>
                        ::core::panicking::panic("internal error: entered unreachable code"),
                }
            }
            fn to_dynamic_enum(&self) -> bevy_reflect::enums::DynamicEnum {
                bevy_reflect::enums::DynamicEnum::from_ref::<Self>(self)
            }
        }
        impl bevy_reflect::PartialReflect for AlphaMode where  {
            #[inline]
            fn get_represented_type_info(&self)
                -> ::core::option::Option<&'static bevy_reflect::TypeInfo> {
                ::core::option::Option::Some(<Self as
                            bevy_reflect::Typed>::type_info())
            }
            #[inline]
            fn try_apply(&mut self,
                __value_param: &dyn bevy_reflect::PartialReflect)
                -> ::core::result::Result<(), bevy_reflect::ApplyError> {
                if let bevy_reflect::ReflectRef::Enum(__value_param) =
                        bevy_reflect::PartialReflect::reflect_ref(__value_param) {
                    if bevy_reflect::enums::Enum::variant_name(self) ==
                            bevy_reflect::enums::Enum::variant_name(__value_param) {
                        match bevy_reflect::enums::Enum::variant_type(__value_param)
                            {
                            bevy_reflect::enums::VariantType::Struct => {
                                for field in
                                    bevy_reflect::enums::Enum::iter_fields(__value_param) {
                                    let name = field.name().unwrap();
                                    if let ::core::option::Option::Some(v) =
                                            bevy_reflect::enums::Enum::field_mut(self, name) {
                                        bevy_reflect::PartialReflect::try_apply(v, field.value())?;
                                    }
                                }
                            }
                            bevy_reflect::enums::VariantType::Tuple => {
                                for (index, field) in
                                    ::core::iter::Iterator::enumerate(bevy_reflect::enums::Enum::iter_fields(__value_param))
                                    {
                                    if let ::core::option::Option::Some(v) =
                                            bevy_reflect::enums::Enum::field_at_mut(self, index) {
                                        bevy_reflect::PartialReflect::try_apply(v, field.value())?;
                                    }
                                }
                            }
                            _ => {}
                        }
                    } else {
                        match bevy_reflect::enums::Enum::variant_name(__value_param)
                            {
                            "Opaque" => { *self = AlphaMode::Opaque {} }
                            "Mask" => {
                                *self =
                                    AlphaMode::Mask {
                                        0: {
                                            let __0 = __value_param.field_at(0usize);
                                            let __0 =
                                                __0.ok_or(bevy_reflect::ApplyError::MissingEnumField {
                                                            variant_name: ::core::convert::Into::into("Mask"),
                                                            field_name: ::core::convert::Into::into(".0"),
                                                        })?;
                                            <f32 as
                                                            bevy_reflect::FromReflect>::from_reflect(__0).ok_or(bevy_reflect::ApplyError::MismatchedTypes {
                                                        from_type: ::core::convert::Into::into(bevy_reflect::DynamicTypePath::reflect_type_path(__0)),
                                                        to_type: ::core::convert::Into::into(<f32 as
                                                                    bevy_reflect::TypePath>::type_path()),
                                                    })?
                                        },
                                    }
                            }
                            "Blend" => { *self = AlphaMode::Blend {} }
                            "Premultiplied" => { *self = AlphaMode::Premultiplied {} }
                            "AlphaToCoverage" => {
                                *self = AlphaMode::AlphaToCoverage {}
                            }
                            "Add" => { *self = AlphaMode::Add {} }
                            "Multiply" => { *self = AlphaMode::Multiply {} }
                            name => {
                                return ::core::result::Result::Err(bevy_reflect::ApplyError::UnknownVariant {
                                            enum_name: ::core::convert::Into::into(bevy_reflect::DynamicTypePath::reflect_type_path(self)),
                                            variant_name: ::core::convert::Into::into(name),
                                        });
                            }
                        }
                    }
                } else {
                    return ::core::result::Result::Err(bevy_reflect::ApplyError::MismatchedKinds {
                                from_kind: bevy_reflect::PartialReflect::reflect_kind(__value_param),
                                to_kind: bevy_reflect::ReflectKind::Enum,
                            });
                }
                ::core::result::Result::Ok(())
            }
            fn reflect_kind(&self) -> bevy_reflect::ReflectKind {
                bevy_reflect::ReflectKind::Enum
            }
            fn reflect_ref(&self) -> bevy_reflect::ReflectRef {
                bevy_reflect::ReflectRef::Enum(self)
            }
            fn reflect_mut(&mut self) -> bevy_reflect::ReflectMut {
                bevy_reflect::ReflectMut::Enum(self)
            }
            fn reflect_owned(self:
                    bevy_reflect::__macro_exports::alloc_utils::Box<Self>)
                -> bevy_reflect::ReflectOwned {
                bevy_reflect::ReflectOwned::Enum(self)
            }
            #[inline]
            fn try_into_reflect(self:
                    bevy_reflect::__macro_exports::alloc_utils::Box<Self>)
                ->
                    ::core::result::Result<bevy_reflect::__macro_exports::alloc_utils::Box<dyn bevy_reflect::Reflect>,
                    bevy_reflect::__macro_exports::alloc_utils::Box<dyn bevy_reflect::PartialReflect>> {
                ::core::result::Result::Ok(self)
            }
            #[inline]
            fn try_as_reflect(&self)
                -> ::core::option::Option<&dyn bevy_reflect::Reflect> {
                ::core::option::Option::Some(self)
            }
            #[inline]
            fn try_as_reflect_mut(&mut self)
                -> ::core::option::Option<&mut dyn bevy_reflect::Reflect> {
                ::core::option::Option::Some(self)
            }
            #[inline]
            fn into_partial_reflect(self:
                    bevy_reflect::__macro_exports::alloc_utils::Box<Self>)
                ->
                    bevy_reflect::__macro_exports::alloc_utils::Box<dyn bevy_reflect::PartialReflect> {
                self
            }
            #[inline]
            fn as_partial_reflect(&self)
                -> &dyn bevy_reflect::PartialReflect {
                self
            }
            #[inline]
            fn as_partial_reflect_mut(&mut self)
                -> &mut dyn bevy_reflect::PartialReflect {
                self
            }
            fn reflect_hash(&self) -> ::core::option::Option<u64> {
                (bevy_reflect::enums::enum_hash)(self)
            }
            fn reflect_partial_eq(&self,
                value: &dyn bevy_reflect::PartialReflect)
                -> ::core::option::Option<bool> {
                (bevy_reflect::enums::enum_partial_eq)(self, value)
            }
            fn reflect_partial_cmp(&self,
                value: &dyn bevy_reflect::PartialReflect)
                -> ::core::option::Option<::core::cmp::Ordering> {
                (bevy_reflect::enums::enum_partial_cmp)(self, value)
            }
            fn debug(&self, f: &mut ::core::fmt::Formatter<'_>)
                -> ::core::fmt::Result {
                ::core::fmt::Debug::fmt(self, f)
            }
            #[inline]
            fn reflect_clone(&self)
                ->
                    ::core::result::Result<bevy_reflect::__macro_exports::alloc_utils::Box<dyn bevy_reflect::Reflect>,
                    bevy_reflect::ReflectCloneError> {
                ::core::result::Result::Ok(bevy_reflect::__macro_exports::alloc_utils::Box::new(::core::clone::Clone::clone(self)))
            }
        }
        impl bevy_reflect::FromReflect for AlphaMode where  {
            fn from_reflect(__param0: &dyn bevy_reflect::PartialReflect)
                -> ::core::option::Option<Self> {
                if let bevy_reflect::ReflectRef::Enum(__param0) =
                        bevy_reflect::PartialReflect::reflect_ref(__param0) {
                    match bevy_reflect::enums::Enum::variant_name(__param0) {
                        "Opaque" =>
                            ::core::option::Option::Some(AlphaMode::Opaque {}),
                        "Mask" =>
                            ::core::option::Option::Some(AlphaMode::Mask {
                                    0: {
                                        let __0 = __param0.field_at(0usize);
                                        let __0 = __0?;
                                        <f32 as bevy_reflect::FromReflect>::from_reflect(__0)?
                                    },
                                }),
                        "Blend" =>
                            ::core::option::Option::Some(AlphaMode::Blend {}),
                        "Premultiplied" =>
                            ::core::option::Option::Some(AlphaMode::Premultiplied {}),
                        "AlphaToCoverage" =>
                            ::core::option::Option::Some(AlphaMode::AlphaToCoverage {}),
                        "Add" => ::core::option::Option::Some(AlphaMode::Add {}),
                        "Multiply" =>
                            ::core::option::Option::Some(AlphaMode::Multiply {}),
                        name => ::core::option::Option::None,
                    }
                } else { ::core::option::Option::None }
            }
        }
    };Reflect, #[automatically_derived]
impl ::core::marker::Copy for AlphaMode { }Copy, #[automatically_derived]
impl ::core::clone::Clone for AlphaMode {
    #[inline]
    fn clone(&self) -> AlphaMode {
        let _: ::core::clone::AssertParamIsClone<f32>;
        *self
    }
}Clone, #[automatically_derived]
impl ::core::cmp::PartialEq for AlphaMode {
    #[inline]
    fn eq(&self, other: &AlphaMode) -> bool {
        let __self_discr = ::core::intrinsics::discriminant_value(self);
        let __arg1_discr = ::core::intrinsics::discriminant_value(other);
        __self_discr == __arg1_discr &&
            match (self, other) {
                (AlphaMode::Mask(__self_0), AlphaMode::Mask(__arg1_0)) =>
                    __self_0 == __arg1_0,
                _ => true,
            }
    }
}PartialEq)]
8#[reflect(Default, Debug, Clone)]
9pub enum AlphaMode {
10    /// Base color alpha values are overridden to be fully opaque (1.0).
11    #[default]
12    Opaque,
13    /// Reduce transparency to fully opaque or fully transparent
14    /// based on a threshold.
15    ///
16    /// Compares the base color alpha value to the specified threshold.
17    /// If the value is below the threshold,
18    /// considers the color to be fully transparent (alpha is set to 0.0).
19    /// If it is equal to or above the threshold,
20    /// considers the color to be fully opaque (alpha is set to 1.0).
21    Mask(f32),
22    /// The base color alpha value defines the opacity of the color.
23    /// Standard alpha-blending is used to blend the fragment's color
24    /// with the color behind it.
25    Blend,
26    /// Similar to [`AlphaMode::Blend`], however assumes RGB channel values are
27    /// [premultiplied](https://en.wikipedia.org/wiki/Alpha_compositing#Straight_versus_premultiplied).
28    ///
29    /// For otherwise constant RGB values, behaves more like [`AlphaMode::Blend`] for
30    /// alpha values closer to 1.0, and more like [`AlphaMode::Add`] for
31    /// alpha values closer to 0.0.
32    ///
33    /// Can be used to avoid “border” or “outline” artifacts that can occur
34    /// when using plain alpha-blended textures.
35    Premultiplied,
36    /// Spreads the fragment out over a hardware-dependent number of sample
37    /// locations proportional to the alpha value. This requires multisample
38    /// antialiasing; if MSAA isn't on, this is identical to
39    /// [`AlphaMode::Mask`] with a value of 0.5.
40    ///
41    /// Alpha to coverage provides improved performance and better visual
42    /// fidelity over [`AlphaMode::Blend`], as Bevy doesn't have to sort objects
43    /// when it's in use. It's especially useful for complex transparent objects
44    /// like foliage.
45    ///
46    /// [alpha to coverage]: https://en.wikipedia.org/wiki/Alpha_to_coverage
47    AlphaToCoverage,
48    /// Combines the color of the fragments with the colors behind them in an
49    /// additive process, (i.e. like light) producing lighter results.
50    ///
51    /// Black produces no effect. Alpha values can be used to modulate the result.
52    ///
53    /// Useful for effects like holograms, ghosts, lasers and other energy beams.
54    Add,
55    /// Combines the color of the fragments with the colors behind them in a
56    /// multiplicative process, (i.e. like pigments) producing darker results.
57    ///
58    /// White produces no effect. Alpha values can be used to modulate the result.
59    ///
60    /// Useful for effects like stained glass, window tint film and some colored liquids.
61    Multiply,
62}
63
64impl Eq for AlphaMode {}