1use bevy_reflect::{std_traits::ReflectDefault, Reflect};
4
5#[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 #[default]
12 Opaque,
13 Mask(f32),
22 Blend,
26 Premultiplied,
36 AlphaToCoverage,
48 Add,
55 Multiply,
62}
63
64impl Eq for AlphaMode {}