Enum PhaseFunction 

pub enum PhaseFunction {
    Isotropic,
    Rayleigh,
    Mie {
        asymmetry: f32,
    },
    Curve(Arc<dyn Curve<f32> + Sync + Send>),
    ChromaticCurve(Arc<dyn Curve<LinearRgba> + Sync + Send>),
    ChromaticTexture(Handle<Image>),
}

Describes how a ScatteringTerm scatters light in different directions.

A phase function is a function f: [-1, 1] -> [0, ∞), symmetric about x=0 whose input is the cosine of the angle between an incoming light direction and and outgoing light direction, and whose output is the proportion of the incoming light that is actually scattered in that direction.

The phase function has an important effect on the “look” of a medium in a scene. Media consisting of particles of a different size or shape scatter light differently, and our brains are very good at telling the difference. A dust cloud, which might correspond roughly to PhaseFunction::Mie { asymmetry: 0.8 }, looks quite different from the rest of the sky (atmospheric gases), which correspond to PhaseFunction::Rayleigh

Variants

Isotropic

A phase function that scatters light evenly in all directions.

Rayleigh

A phase function representing Rayleigh scattering.

Rayleigh scattering occurs naturally for particles much smaller than the wavelengths of visible light, such as gas molecules in the atmosphere. It’s generally wavelength-dependent, where shorter wavelengths are scattered more strongly, so scattering should have higher values for blue than green and green than red. Particles that participate in Rayleigh scattering don’t absorb any light, either.

Mie

The Henyey-Greenstein phase function, which approximates Mie scattering.

Mie scattering occurs naturally for spherical particles of dust and aerosols roughly the same size as the wavelengths of visible light, so it’s useful for representing dust or sea spray. It’s generally wavelength-independent, so absorption and scattering should be set to a greyscale value.

Fields

asymmetry: f32

Whether the Mie scattering function is biased towards scattering light forwards (asymmetry > 0) or backwards (asymmetry < 0).

domain: [-1, 1]

Curve(Arc<dyn Curve<f32> + Sync + Send>)

A phase function defined by a custom curve, where the input is the cosine of the angle between the incoming light ray and the scattered light ray, and the output is the fraction of the incoming light scattered in that direction.

Note: it’s important for photorealism that the phase function be energy conserving, meaning that in total no more light can be scattered than actually entered the medium. For this to be the case, the integral of the phase function over its domain must be equal to 1/2π.

1 ∫ p(x) dx = 1/2π -1

domain: [-1, 1] range: [0, 1]

ChromaticCurve(Arc<dyn Curve<LinearRgba> + Sync + Send>)

A wavelength-dependent (chromatic) phase function returning linear RGB phase values per channel. Used when the phase varies with wavelength, for instance Mie scattering on Martian dust.

Energy conservation applies per channel. Each of the channels must independently satisfy the equation above.

domain: [-1, 1] range: [0, 1] per channel (R, G, B)

ChromaticTexture(Handle<Image>)

A chromatic phase function sampled from an N×1 texture (R,G,B per column).

Use Rgba32Float format. Columns map linearly to cos θ. The LUT spans the scattering hemisphere: first column is back-scattering (θ = π), last is forward-scattering (θ = 0). Resolved to PhaseFunction::ChromaticCurve when the image loads.

To generate your own, compute the phase function using Mie theory (for example, using the miepython package) and write it as a 32-bit float texture (OpenEXR or KTX2).

Implementations

impl PhaseFunction

pub fn from_curve( curve: impl Curve<f32> + Send + Sync + 'static, ) -> PhaseFunction

A phase function defined by a custom curve.

pub fn from_chromatic_curve( curve: impl Curve<LinearRgba> + Send + Sync + 'static, ) -> PhaseFunction

A wavelength-dependent phase function from a curve that returns linear RGBA.

pub fn from_chromatic_texture(image: Handle<Image>) -> PhaseFunction

A chromatic phase function from an N×1 texture. Resolved to a curve when loaded.

pub fn sample(&self, neg_l_dot_v: f32) -> Option<LinearRgba>

Samples the phase function at the given value in [-1, 1].

Returns Some(LinearRgba) with per-channel phase values (scalar phases use R=G=B). Returns None when the phase is not yet available (e.g. PhaseFunction::ChromaticTexture before load).

Trait Implementations

impl Clone for PhaseFunction

fn clone(&self) -> PhaseFunction

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Default for PhaseFunction

fn default() -> PhaseFunction

Returns the “default value” for a type.