9b32e09551
# Objective Now that #13432 has been merged, it's important we update our reflected types to properly opt into this feature. If we do not, then this could cause issues for users downstream who want to make use of reflection-based cloning. ## Solution This PR is broken into 4 commits: 1. Add `#[reflect(Clone)]` on all types marked `#[reflect(opaque)]` that are also `Clone`. This is mandatory as these types would otherwise cause the cloning operation to fail for any type that contains it at any depth. 2. Update the reflection example to suggest adding `#[reflect(Clone)]` on opaque types. 3. Add `#[reflect(clone)]` attributes on all fields marked `#[reflect(ignore)]` that are also `Clone`. This prevents the ignored field from causing the cloning operation to fail. Note that some of the types that contain these fields are also `Clone`, and thus can be marked `#[reflect(Clone)]`. This makes the `#[reflect(clone)]` attribute redundant. However, I think it's safer to keep it marked in the case that the `Clone` impl/derive is ever removed. I'm open to removing them, though, if people disagree. 4. Finally, I added `#[reflect(Clone)]` on all types that are also `Clone`. While not strictly necessary, it enables us to reduce the generated output since we can just call `Clone::clone` directly instead of calling `PartialReflect::reflect_clone` on each variant/field. It also means we benefit from any optimizations or customizations made in the `Clone` impl, including directly dereferencing `Copy` values and increasing reference counters. Along with that change I also took the liberty of adding any missing registrations that I saw could be applied to the type as well, such as `Default`, `PartialEq`, and `Hash`. There were hundreds of these to edit, though, so it's possible I missed quite a few. That last commit is **_massive_**. There were nearly 700 types to update. So it's recommended to review the first three before moving onto that last one. Additionally, I can break the last commit off into its own PR or into smaller PRs, but I figured this would be the easiest way of doing it (and in a timely manner since I unfortunately don't have as much time as I used to for code contributions). ## Testing You can test locally with a `cargo check`: ``` cargo check --workspace --all-features ```
63 lines
2.8 KiB
Rust
63 lines
2.8 KiB
Rust
use bevy_reflect::{std_traits::ReflectDefault, Reflect};
|
|
|
|
// TODO: add discussion about performance.
|
|
/// Sets how a material's base color alpha channel is used for transparency.
|
|
#[derive(Debug, Default, Reflect, Copy, Clone, PartialEq)]
|
|
#[reflect(Default, Debug, Clone)]
|
|
pub enum AlphaMode {
|
|
/// Base color alpha values are overridden to be fully opaque (1.0).
|
|
#[default]
|
|
Opaque,
|
|
/// Reduce transparency to fully opaque or fully transparent
|
|
/// based on a threshold.
|
|
///
|
|
/// Compares the base color alpha value to the specified threshold.
|
|
/// If the value is below the threshold,
|
|
/// considers the color to be fully transparent (alpha is set to 0.0).
|
|
/// If it is equal to or above the threshold,
|
|
/// considers the color to be fully opaque (alpha is set to 1.0).
|
|
Mask(f32),
|
|
/// The base color alpha value defines the opacity of the color.
|
|
/// Standard alpha-blending is used to blend the fragment's color
|
|
/// with the color behind it.
|
|
Blend,
|
|
/// Similar to [`AlphaMode::Blend`], however assumes RGB channel values are
|
|
/// [premultiplied](https://en.wikipedia.org/wiki/Alpha_compositing#Straight_versus_premultiplied).
|
|
///
|
|
/// For otherwise constant RGB values, behaves more like [`AlphaMode::Blend`] for
|
|
/// alpha values closer to 1.0, and more like [`AlphaMode::Add`] for
|
|
/// alpha values closer to 0.0.
|
|
///
|
|
/// Can be used to avoid “border” or “outline” artifacts that can occur
|
|
/// when using plain alpha-blended textures.
|
|
Premultiplied,
|
|
/// Spreads the fragment out over a hardware-dependent number of sample
|
|
/// locations proportional to the alpha value. This requires multisample
|
|
/// antialiasing; if MSAA isn't on, this is identical to
|
|
/// [`AlphaMode::Mask`] with a value of 0.5.
|
|
///
|
|
/// Alpha to coverage provides improved performance and better visual
|
|
/// fidelity over [`AlphaMode::Blend`], as Bevy doesn't have to sort objects
|
|
/// when it's in use. It's especially useful for complex transparent objects
|
|
/// like foliage.
|
|
///
|
|
/// [alpha to coverage]: https://en.wikipedia.org/wiki/Alpha_to_coverage
|
|
AlphaToCoverage,
|
|
/// Combines the color of the fragments with the colors behind them in an
|
|
/// additive process, (i.e. like light) producing lighter results.
|
|
///
|
|
/// Black produces no effect. Alpha values can be used to modulate the result.
|
|
///
|
|
/// Useful for effects like holograms, ghosts, lasers and other energy beams.
|
|
Add,
|
|
/// Combines the color of the fragments with the colors behind them in a
|
|
/// multiplicative process, (i.e. like pigments) producing darker results.
|
|
///
|
|
/// White produces no effect. Alpha values can be used to modulate the result.
|
|
///
|
|
/// Useful for effects like stained glass, window tint film and some colored liquids.
|
|
Multiply,
|
|
}
|
|
|
|
impl Eq for AlphaMode {}
|