audionimbus 0.14.0

A safe wrapper around Steam Audio that provides spatial audio capabilities with realistic occlusion, reverb, and HRTF effects, accounting for physical attributes and scene geometry.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101

//! Ray tracing implementations.

use crate::Sealed;
use crate::callback::CustomRayTracingUserData;
use crate::device::{EmbreeDevice, RadeonRaysDevice};
use std::fmt::Debug;
use std::sync::Arc;

/// Steam Audio’s built-in ray tracer.
///
/// Supports multi-threading. Runs on all platforms that Steam Audio supports.
#[derive(Debug)]
pub struct DefaultRayTracer;

/// The Intel Embree ray tracer.
///
/// Supports multi-threading.
/// This is a highly optimized implementation, and is likely to be faster than the default ray tracer.
/// However, Embree requires Windows, Linux, or macOS, and a 32-bit x86 or 64-bit x86_64 CPU.
#[derive(Debug)]
pub struct Embree;

/// The AMD Radeon Rays ray tracer.
///
/// This is an OpenCL implementation, and can use either the CPU or any GPU that supports OpenCL 1.2 or later.
/// If using the GPU, it is likely to be significantly faster than the default ray tracer.
/// However, with heavy real-time simulation workloads, it may impact your application’s frame rate.
/// On supported AMD GPUs, you can use the Resource Reservation feature to mitigate this issue.
#[derive(Debug)]
pub struct RadeonRays;

/// Allows you to specify callbacks to your own ray tracer.
///
/// Useful if your application already uses a high-performance ray tracer.
/// This option uses the least amount of memory at run-time, since it does not have to build any ray tracing data structures of its own.
#[derive(Debug)]
pub struct CustomRayTracer;

impl Sealed for DefaultRayTracer {}
impl Sealed for Embree {}
impl Sealed for RadeonRays {}
impl Sealed for CustomRayTracer {}

/// Ray tracer implementation. Can be:
/// - [`DefaultRayTracer`]: Steam Audio’s built-in ray tracer
/// - [`Embree`]: The Intel Embree ray tracer
/// - [`RadeonRays`]: The AMD Radeon Rays ray tracer
/// - [`CustomRayTracer`]: Allows you to specify callbacks to your own ray tracer
pub trait RayTracer: Sealed {
    type Device: Debug + Send + Sync;
    type CallbackUserData: Debug + Send + Sync;

    /// Returns the FFI scene type for this ray tracer implementation.
    fn scene_type() -> audionimbus_sys::IPLSceneType;
}

impl RayTracer for DefaultRayTracer {
    type Device = ();
    type CallbackUserData = ();

    fn scene_type() -> audionimbus_sys::IPLSceneType {
        audionimbus_sys::IPLSceneType::IPL_SCENETYPE_DEFAULT
    }
}

impl RayTracer for Embree {
    type Device = EmbreeDevice;
    type CallbackUserData = ();

    fn scene_type() -> audionimbus_sys::IPLSceneType {
        audionimbus_sys::IPLSceneType::IPL_SCENETYPE_EMBREE
    }
}

impl RayTracer for RadeonRays {
    type Device = RadeonRaysDevice;
    type CallbackUserData = ();

    fn scene_type() -> audionimbus_sys::IPLSceneType {
        audionimbus_sys::IPLSceneType::IPL_SCENETYPE_RADEONRAYS
    }
}

impl RayTracer for CustomRayTracer {
    type Device = ();
    type CallbackUserData = CustomCallbackUserData;

    fn scene_type() -> audionimbus_sys::IPLSceneType {
        audionimbus_sys::IPLSceneType::IPL_SCENETYPE_CUSTOM
    }
}

/// Callback user data used with a custom ray tracer.
#[derive(Debug)]
pub struct CustomCallbackUserData(
    /// Never read directly.
    /// Held here so that the underlying data is not freed, since the FFI layer holds a raw pointer
    /// to it.
    #[allow(dead_code)]
    pub(crate) Arc<CustomRayTracingUserData>,
);