Struct IPLSimulationInputs 

#[repr(C)]
pub struct IPLSimulationInputs {

    pub flags: IPLSimulationFlags,
    pub directFlags: IPLDirectSimulationFlags,
    pub source: IPLCoordinateSpace3,
    pub distanceAttenuationModel: IPLDistanceAttenuationModel,
    pub airAbsorptionModel: IPLAirAbsorptionModel,
    pub directivity: IPLDirectivity,
    pub occlusionType: IPLOcclusionType,
    pub occlusionRadius: IPLfloat32,
    pub numOcclusionSamples: IPLint32,
    pub reverbScale: [IPLfloat32; 3],
    pub hybridReverbTransitionTime: IPLfloat32,
    pub hybridReverbOverlapPercent: IPLfloat32,
    pub baked: IPLbool,
    pub bakedDataIdentifier: IPLBakedDataIdentifier,
    pub pathingProbes: IPLProbeBatch,
    pub visRadius: IPLfloat32,
    pub visThreshold: IPLfloat32,
    pub visRange: IPLfloat32,
    pub pathingOrder: IPLint32,
    pub enableValidation: IPLbool,
    pub findAlternatePaths: IPLbool,
    pub numTransmissionRays: IPLint32,
    pub deviationModel: *mut IPLDeviationModel,
}

Simulation parameters for a source.

Fields

flags: IPLSimulationFlags

The types of simulation to run for this source.

directFlags: IPLDirectSimulationFlags

The types of direct simulation to run for this source.

source: IPLCoordinateSpace3

The position and orientation of this source.

distanceAttenuationModel: IPLDistanceAttenuationModel

The distance attenuation model to use for this source.

airAbsorptionModel: IPLAirAbsorptionModel

The air absorption model to use for this source.

directivity: IPLDirectivity

The directivity pattern to use for this source.

occlusionType: IPLOcclusionType

The occlusion algorithm to use for this source.

occlusionRadius: IPLfloat32

If using volumetric occlusion, the source is modeled as a sphere with this radius.

numOcclusionSamples: IPLint32

If using volumetric occlusion, this is the number of point samples to consider when tracing rays. This value can change between simulation runs.

reverbScale: [IPLfloat32; 3]

If using parametric or hybrid reverb for rendering reflections, the reverb decay times for each frequency band are scaled by these values. Set to \c {1.0f, 1.0f, 1.0f} to use the simulated values without modification.

hybridReverbTransitionTime: IPLfloat32

If using hybrid reverb for rendering reflections, this is the length (in seconds) of impulse response to use for convolution reverb. The rest of the impulse response will be used for parametric reverb estimation only. Increasing this value results in more accurate reflections, at the cost of increased CPU usage.

hybridReverbOverlapPercent: IPLfloat32

If using hybrid reverb for rendering reflections, this is the amount of overlap between the convolution and parametric parts. To ensure smooth transitions from the early convolution part to the late parametric part, the two are cross-faded towards the end of the convolution part. For example, if \c hybridReverbTransitionTime is \c 1.0f, and \c hybridReverbOverlapPercent is \c 0.25f, then the first 0.75 seconds are pure convolution, the next 0.25 seconds are a blend between convolution and parametric, and the portion of the tail beyond 1.0 second is pure parametric.

baked: IPLbool

If \c IPL_TRUE, this source will used baked data for reflections simulation.

bakedDataIdentifier: IPLBakedDataIdentifier

The identifier used to specify which layer of baked data to use for simulating reflections for this source.

pathingProbes: IPLProbeBatch

The probe batch within which to find paths from this source to the listener.

visRadius: IPLfloat32

When testing for mutual visibility between a pair of probes, each probe is treated as a sphere of this radius (in meters), and point samples are generated within this sphere.

visThreshold: IPLfloat32

When tracing rays to test for mutual visibility between a pair of probes, the fraction of rays that are unoccluded must be greater than this threshold for the pair of probes to be considered mutually visible.

visRange: IPLfloat32

If the distance between two probes is greater than this value, the probes are not considered mutually visible. Increasing this value can result in simpler paths, at the cost of increased CPU usage.

pathingOrder: IPLint32

If simulating pathing, this is the Ambisonic order used for representing path directionality. Higher values result in more precise spatialization of paths, at the cost of increased CPU usage.

enableValidation: IPLbool

If \c IPL_TRUE, baked paths are tested for visibility. This is useful if your scene has dynamic objects that might occlude baked paths.

findAlternatePaths: IPLbool

If \c IPL_TRUE, and \c enableValidation is \c IPL_TRUE, then if a baked path is occluded by dynamic geometry, path finding is re-run in real-time to find alternate paths that take into account the dynamic geometry.

numTransmissionRays: IPLint32

If simulating transmission, this is the maximum number of surfaces, starting from the closest surface to the listener, whose transmission coefficients will be considered when calculating the total amount of sound transmitted. Increasing this value will result in more accurate results when multiple surfaces lie between the source and the listener, at the cost of increased CPU usage.

deviationModel: *mut IPLDeviationModel

The deviation model to use for this source. Only used when simulating pathing.

Trait Implementations

impl Clone for IPLSimulationInputs

fn clone(&self) -> IPLSimulationInputs

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for IPLSimulationInputs

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

Formats the value using the given formatter.

impl Copy for IPLSimulationInputs