Enum AlphaMode 

pub enum AlphaMode {
    Opaque,
    Mask(f32),
    Blend,
}

Specifies how a material handles transparency and alpha blending.

This enum is critical for the rendering system to make intelligent decisions about render pass ordering and pipeline selection. Different alpha modes have significant performance implications:

• Opaque: Fastest, no transparency calculations
• Mask: Fast, no sorting required, uses alpha testing
• Blend: Slowest, requires depth sorting for correct rendering

Examples

use khora_core::asset::AlphaMode;

// Opaque material (default for most objects)
let opaque = AlphaMode::Opaque;

// Alpha masking (e.g., foliage, chain-link fences)
let masked = AlphaMode::Mask(0.5); // Discard pixels with alpha < 0.5

// Full blending (e.g., glass, water)
let blended = AlphaMode::Blend;

Variants

Opaque

The material is fully opaque with no transparency.

This is the default and most performant mode. Fragments are always written to the framebuffer without alpha testing or blending.

Mask(f32)

The material uses alpha testing to create binary transparency.

Fragments with an alpha value below the specified threshold are discarded. This mode is useful for rendering vegetation, chain-link fences, or other objects with hard transparency edges. It’s significantly faster than Blend because it doesn’t require depth sorting.

The f32 value is the alpha cutoff threshold (typically 0.5).

Blend

The material uses full alpha blending.

This mode produces smooth transparency but requires objects to be rendered in back-to-front order for correct results. The RenderAgent may choose different rendering strategies based on the number of blend-mode objects in the scene to balance quality and performance.

Trait Implementations

impl<'__de, __Context> BorrowDecode<'__de, __Context> for AlphaMode

fn borrow_decode<__D>(decoder: &mut __D) -> Result<AlphaMode, DecodeError>

where __D: BorrowDecoder<'__de, Context = __Context>,

Attempt to decode this type with the given BorrowDecode.

impl Clone for AlphaMode

fn clone(&self) -> AlphaMode

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for AlphaMode

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

Formats the value using the given formatter.

impl<__Context> Decode<__Context> for AlphaMode

fn decode<__D>(decoder: &mut __D) -> Result<AlphaMode, DecodeError>

where __D: Decoder<Context = __Context>,

Attempt to decode this type with the given Decode.

impl Default for AlphaMode

fn default() -> AlphaMode

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for AlphaMode

fn deserialize<__D>( __deserializer: __D, ) -> Result<AlphaMode, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Encode for AlphaMode

fn encode<__E>(&self, encoder: &mut __E) -> Result<(), EncodeError>

where __E: Encoder,

Encode a given type.

impl PartialEq for AlphaMode

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

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Copy for AlphaMode

impl StructuralPartialEq for AlphaMode