Warning: you were redirected to the latest documentation corresponding to your major release ( 2023.1.8.8601 ). Should you wish to access your specific version's documentation, please download the offline documentation from the Audiokinetic Launcher and check the Offline Documentation option in Wwise Authoring.

Wwise SDK 2023.1.8

Introduction

Raytracing is a technique for efficiently evaluating nth-order reflection and diffraction. The basic idea is to randomly cast rays from the listener and follow their paths through a series of reflections and diffraction. The technique is inspired by graphic rendering techniques. Maximum Reflection order [1-4] and diffraction order [1-8] values are defined in the AkSpatialAudioInitSettings structure of AkSpatialAudio.h. Refer to AkSpatialAudioInitSettings for more details.

Concepts

Primary rays: the rays directly cast from the listener
Reflection: bouncing of sound on surfaces
Diffraction: bending of sound around objects
Paths: series of reflections/diffractions from the listener to an emitter

Settings

In order to tweak spatial audio CPU performance and quality, the raytracing engine uses several parameters. For a detailed description of the spatial audio settings, see AkSpatialAudioInitSettings().

CPU Limit Mode

Tweaking the number of primary rays can be tricky as it depends on the complexity of the scene (for example, the number of triangles and diffraction edges) and the number of emitters. When CPU Limit Mode is active, the raytracing engine automatically adapts the number of primary rays to ensure CPU usage remains around the target value defined by the user. Although this mode minimizes peaks in CPU usage it cannot completely remove short and sudden peaks. Setting a high target value increases quality (number of reflection and diffraction paths found) at the cost of performance. While setting a low target value increases performance at the cost of quality. When CPU Limit Mode is active, the number of primary rays is capped at the user-defined number of primary rays (see AkSpatialAudioInitSettings). When the number of primary rays drops to 0, the raytracing engine stops scanning the environment. However, the existing sound propagation paths are still validated and updated. As a consequence, the raytracing engine still consumes CPU. Note that CPU Limit Mode doesn't have a significant effect on portal ray tracing. Portal ray tracing increases the CPU load and might therefore force the CPU Limit Mode to temporarily reduce the number of primary rays.

Load Balancing

Load balancing provides a way to flatten CPU peaks by distributing spatial audio task computation over several frames. Spatial audio executes different types of tasks, such as ray casting and path validation, to compute the sound propagation paths (reflections and diffraction). Whenever one of these tasks needs to be performed, it is placed in a priority queue for further processing instead of being executed immediately. The tasks in the queue are then executed over the number of frames specified in the load balancing spread setting.

Load Balancing Use Cases

There are several ways to tweak spatial audio performance: you can apply a CPU limit, change the order of reflection, enable or disable diffraction and diffraction on reflections, and adjust the motion threshold setting. You can combine load balancing with the other settings to achieve the desired balance between quality and performance.

Although load balancing can be used in any scenario, it is most appropriate for scenes that involve multiple active emitters. Load balancing behavior is controlled through the AkSpatialAudioInitSettings::uLoadBalancingSpread setting (see AkSpatialAudioInitSettings). A spread of 1 frame is equivalent to disabling the feature, because every task is executed immediately. Higher values increase CPU performance, but can lead to less accurate results. For example, a spread of 4 frames for a frame buffer of 1024 samples (around 21ms at 48kHz) executes the tasks over a period of 84 ms. Spread values under 10 should not noticeably affect quality.

Load Balancing Example

The following example compares the performance in the same scene with three different spread values: 1 (disable), 4, and 10. The scene has 944 triangles and 649 diffraction edges. The number of emitters is 4. Reflection order is set to 4 and diffraction is enabled.

An urban environment with several emitters.

The following table shows the effect of different load balancing values on the scene.

Spread	Average CPU %	Max CPU %
Disabled	4.8	52.76
4	3.16	23.26
10	1.71	10.22

With load balancing disabled, the number of emitters in a frame can go up to 4, which leads to high CPU peaks.

With a spread of 4, a maximum of 2 emitters are processed in a given frame, which lowers the CPU peaks.

With a spread of 10, only 1 emitter is processed in a given frame, which reduces CPU peaks even more.

Load Balancing FAQ

Does load balancing cause delays?

Not exactly. It can introduce a "delay" in updating path information, but does not add latency to the audio signal. For instance, the same rays might be used until the next update. The paths are still computed at each frame, but are not validated at each frame. This means that some paths might be less accurate. For instance, specular reflection positions might be slightly inaccurate.
Does the load balancing improve the average CPU performance?

Although load balancing primarily focuses on decreasing CPU peaks, it can also decrease CPU averages because it prevents the same type of task from appearing in the queue multiple times. If a task is in the queue, it must be executed before another task of the same type can be added to the queue.
Does load balancing improve CPU performance when there is only one emitter?

Not significantly. Path validation is the most CPU-intensive spatial audio task. Given that one path validation task is executed for each emitter, load balancing is more appropriate for situations that involve several emitters. However, it can slightly improve single-emitter scenarios by preventing redundant computations.

Load Balancing in Depth

Whenever a spatial audio task needs to be performed, it is placed in a priority queue for further processing instead of being executed immediately. If the task is already in the queue, it is not placed in the queue again. This prevents redundant computation and reduces CPU consumption. At each frame, the number of tasks to process (N) is computed based on the number of elements in the queue and the load balancing spread settings. The first N priority tasks are pulled from the queue and executed.

In general, task priority is determined by the time at which the task was created (inserted): older tasks are executed first. For some tasks, such as the path validation tasks, the priority might be different. Whenever an emitter becomes active, the path validation task priority is increased to force the validation of the new paths. This is important to prevent delays in path creation.

A task is placed in the queue if it is not already scheduled.

At each frame, N tasks are pulled from the queue for execution.

There are 7 elements in the queue and the load balancing spread is set to 3. The number of tasks (N) that will be executed in this frame is CEIL(7/3) = 3. The tasks T1, T2, and T3 will be executed in the same frame. The process is repeated in the next frame.

Limitations

There are a few limitations when defining geometries for the raytracing engine. The limitations concern both the performance and the quality of the results.

Geometry visible angle

When a triangle is smaller than the sampling density, the raytracing engine is less likely to find it.

The geometry's visible angle alpha is the angle at which the geometry is seen from the point of view of the listener. Depending on the number of primary rays, the average angle (gamma) between two rays varies. The relation between alpha and gamma influences the probability of finding an intersection (a reflection or a diffraction) with the object. If gamma is smaller than alpha, the probability of finding an intersection is high. If gamma is bigger than alpha, the probability of finding an intersection is low.

In this example, gamma is smaller than alpha. Hence, the probability of finding an intersection with the object is high.

In this example, alpha is smaller than gamma. Hence, the probability of finding an intersection with the object is low.

Number of triangles

The number of triangles contained in the geometry is directly related to the CPU usage of the engine: the more triangles, the higher the CPU usage. This is due to the fact that more intersection tests are required on the object. Usually, sound propagation does not require highly detailed geometry. Reducing the number of triangles can help increase the performance without sacrificing quality.

Here the plane is composed of 4 triangles: the rays have to be tested against each triangle.

Geometry shape

Some geometry shapes are more difficult to process than others. Usually, geometries like planes and boxes are simple to process and give the best results in terms of sound propagation. Spheres and cylinders are more prone to errors. This is due to the curvature introduced by the sphere and the cylinder. Some diffraction edges may not be found, which would cause some diffraction paths to be missed. The algorithm implements several heuristics to overcome this issue in most cases. Increasing the number of primary rays or simplifying the geometry can solve the issue as well.

In this situation, we expect to find the diffraction path from L to E that goes through L, E2, E3, E4, and E. Unfortunately, the surface between E1 and E2 is small and thus it is difficult to find the necessary intersection that will provide the diffraction edge E2. In this case, the intersection with E1 is more likely. L is not in the shadow zone of E1, preventing the algorithm from actually finding the diffraction path from E2.

Performance Tweaking

The following table provides information you can use to tweak parameters for different use cases.

Symptoms	Possible solutions
Spatial Audio - General CPU issues	Decrease the order of reflection: 1st and 2nd order of reflection are sufficient in most cases. Disable diffraction or reflection on diffraction if not needed: computing diffraction is CPU intensive. Instead of completely disabling diffraction, reduce the number of diffraction edges in the scene if possible. Use rooms and portals: if your scene is composed of independent sections, consider using rooms and portals to isolate them. Increase the motion threshold: small values might validate reflection and diffraction paths too often. Consider setting this to the highest possible value that maintains good quality results. Low values might introduce some inaccuracy in the reflection and diffraction paths. Some examples of inaccuracy: reflections might not be perfectly specular, some paths might be discovered with some delay, some invalid paths might be removed later than expected. Decrease the number of triangles if possible: objects with a high level of detail increase CPU cost and tend to decrease overall quality.
Spatial Audio - Raytracing CPU is high	Decrease the number of primary rays: values as low as 5 can still produce good results. Enable CPU limit (CPU Limit Mode): set your desired CPU percentage, and the feature will automatically control the number of primary rays to keep the CPU around the specified value. Note that this will have no effect on portal ray tracing.
Spatial Audio - Path Validation CPU is high and there is only one emitter	Disable diffraction or reflection on diffraction if not needed: computing diffraction is CPU intensive. Instead of completely disabling diffraction, reduce the number of diffraction edges in the scene if possible.
Spatial Audio - Path Validation CPU is high and there are multiple emitters	Enable load balancing: start with a value lower than 10 and adjust if necessary. Values lower than 10 should not noticeably affect quality.
Spatial Audio - CPU is high (path validation and ray tracing are both involved) and there is only one emitter	Enable load balancing: use a value of 2. It will spread the computation of ray tracing and path validation on different frames and thus reduce the peaks. Higher values won't help much. Increase the motion threshold: in this case, it reduces average CPU consumption more than it reduces the peaks.

Was this page helpful?

Need Support?

Questions? Problems? Need more info? Contact us, and we can help!

Visit our Support page

Tell us about your project. We're here to help.

Get started with Wwise

Wwise SDK

Raytracing Engine Geometry Guide