Enum AttenuationModel 

pub enum AttenuationModel {
    Linear,
    InverseDistance,
    Exponential {
        rolloff: f32,
    },
    None,
}

Audio attenuation model for distance-based volume falloff.

Controls how audio volume decreases with distance from the listener. Different models provide different falloff curves for realistic or stylized audio behavior.

Models

• Linear: Linear falloff (volume = 1 - distance/max_distance)
• InverseDistance: Realistic inverse distance falloff (volume = 1 / (1 + distance))
• Exponential: Exponential falloff (volume = (1 - distance/max_distance)^rolloff)
• None: No attenuation (constant volume regardless of distance)

Examples

use goud_engine::ecs::components::AttenuationModel;

let linear = AttenuationModel::Linear;
let inverse = AttenuationModel::InverseDistance;
let exponential = AttenuationModel::Exponential { rolloff: 2.0 };
let none = AttenuationModel::None;

assert_eq!(linear.name(), "Linear");
assert_eq!(inverse.name(), "InverseDistance");

Variants

Linear

Linear falloff: volume = max(0, 1 - distance/max_distance)

InverseDistance

Inverse distance falloff: volume = 1 / (1 + distance)

Exponential

Exponential falloff: volume = max(0, (1 - distance/max_distance)^rolloff)

Fields

rolloff: f32

The exponent for the falloff curve.

None

No attenuation (constant volume)

Implementations

impl AttenuationModel

pub fn name(&self) -> &str

Returns the model name for debugging.

pub fn compute_attenuation(&self, distance: f32, max_distance: f32) -> f32

Computes the attenuation factor (0.0-1.0) based on distance.

Arguments

• distance: Distance from listener (must be >= 0)
• max_distance: Maximum distance for attenuation (must be > 0)

Returns

Volume multiplier in range [0.0, 1.0]

Examples

use goud_engine::ecs::components::AttenuationModel;

let model = AttenuationModel::Linear;
assert_eq!(model.compute_attenuation(0.0, 100.0), 1.0);
assert_eq!(model.compute_attenuation(50.0, 100.0), 0.5);
assert_eq!(model.compute_attenuation(100.0, 100.0), 0.0);
assert_eq!(model.compute_attenuation(150.0, 100.0), 0.0); // Beyond max

Trait Implementations

impl Clone for AttenuationModel

fn clone(&self) -> AttenuationModel

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for AttenuationModel

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

Formats the value using the given formatter.

impl Default for AttenuationModel

fn default() -> AttenuationModel

Returns AttenuationModel::InverseDistance as the default (most realistic).

impl<'de> Deserialize<'de> for AttenuationModel

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for AttenuationModel

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

Formats the value using the given formatter.

impl PartialEq for AttenuationModel

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

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 AttenuationModel

impl StructuralPartialEq for AttenuationModel