Module steam_audio::ffi

Structs

IPLAudioBuffer	A buffer containing audio data. All audio data passed to or from Phonon must be packaged in \c IPLAudioBuffer objects, which describe the format and size of the audio data.
IPLAudioFormat	The format of an audio buffer. Whenever you pass audio data to or from Phonon, you must describe the format in which the audio is encoded. Phonon only supports uncompressed PCM wave data, stored in 32-bit floating point format. However, Phonon supports many different multi-channel and Ambisonics formats, and the \c IPLAudioFormat tells Phonon how to interpret a buffer of audio data.
IPLBakedDataIdentifier	Identifies a set of baked data. It is the application's responsibility to ensure that this data is unique across the lifetime of an Environment object.
IPLBakingSettings	Specifies the kind of acoustic responses to save in the baked data.
IPLBox	An axis-aligned box. Axis-aligned boxes are used to specify a volume of 3D space.
IPLComplex	A single-precision complex number.
IPLComputeDeviceFilter	Specifies constraints on the type of OpenCL device to create. This information is intended to be passed to \c iplCreateComputeDevice.
IPLDirectSoundEffectOptions	Flags that specify which parameters from \c IPLDirectSoundPath should be applied by the Direct Sound Effect.
IPLDirectSoundPath	Parameters describing a direct sound path. For each frequency band, the attenuation factor applied to the direct sound path is:
IPLHrtfParams	Parameters used to describe the HRTF database you want to use when creating a Binaural Renderer object.
IPLMaterial	The acoustic properties of a surface. You can specify the acoustic material properties of each triangle, although typically many triangles will share a common material. The acoustic material properties are specified for three frequency bands with center frequencies of 400 Hz, 2.5 KHz, and 15 KHz.
IPLOrientedBox	An oriented box. Oriented boxes are used to specify a volume of 3D space.
IPLProbePlacementParams	Parameters that specify how probes should be created by \c ::iplCreateProbeBox.
IPLQuaternion	A unit-length quaternion. Quaternions are used to represent a rotation or orientation.
IPLRenderingSettings	Describes various properties of the audio processing pipeline. Many Phonon API objects that are used by the audio engine need to know how the audio processing pipeline (i.e., your audio engine) applies DSP effects to audio data. This structure describes the key parameters.
IPLSimulationSettings	Configures the complexity of the simulation. You can fine-tune these values to arrive at a suitable balance between performance, memory usage, and acoustic detail.
IPLSphere	A sphere. Spheres are used to define a region of influence around a point.
IPLTriangle	A triangle in 3D space. Triangles are specified by their three vertices, which are in turn specified using indices into a vertex array. See iplSetStaticMeshVertices for how to specify the vertex array. Phonon uses a counter-clockwise winding order. This means that when looking at the triangle such that the normal is pointing towards you, the vertices are specified in counter-clockwise order.
IPLVector3	A point or vector in 3D space. Phonon uses a right-handed coordinate system, with the positive x-axis pointing right, the positive y-axis pointing up, and the negative z-axis pointing ahead. Position and direction data obtained from a game engine or audio engine must be properly transformed before being passed to any Phonon API function.
max_align_t

Enums

IPLAmbisonicsNormalization	Normalization conventions for Ambisonics channels. There are a few different ways of normalizing the values of the Ambisonics channels relative to each other. Phonon supports the most popular ones.
IPLAmbisonicsOrdering	The order in which Ambisonics channels are stored in an audio buffer. Each Ambisonics channel is a series of coefficients for a corresponding basis function, denoted by \f$ Y_lm(\theta,\phi) \f$, where \f$\theta\f$ and \f$\phi\f$ are two angles which pinpoint the source relative to the listener, and \f$l\f$ and \f$m\f$ are two two integers which, taken together, identify a single Ambisonics channel. Here, \f$ l \geq 0 \f$ and \f$ -l \leq m \leq l \f$.
IPLBakedDataType	Defines how a set of baked data should be interpreted.
IPLChannelLayout	The type of speaker configuration, for audio formats that are not encoded using Ambisonics.
IPLChannelLayoutType	Whether the audio buffer is encoded using Ambisonics or not.
IPLChannelOrder	Whether the data is interleaved or deinterleaved.
IPLComputeDeviceType	The type of device to use with OpenCL. The appropriate OpenCL drivers must be installed on the user's system. Multiple OpenCL drivers may be installed on the same system; in this case the first available driver that exposes the specified kind of device will be used.
IPLConvolutionType	The backend to use for applying convolution effects for sound propagation. Phonon lets you choose from multiple convolution implementations, with different trade-offs.
IPLDirectOcclusionMethod	The algorithm to use when checking for direct path occlusion. Phonon can check whether a direct sound path is occluded by scene geometry, and optionally how much of a sound source is occluded.
IPLDirectOcclusionMode	The method to use when rendering occluded or partially occluded sound. Phonon can model sound passing through solid objects, and optionally apply frequency-dependent transmission filters.
IPLHrtfDatabaseType	The type of HRTF database to use for binaural rendering. You can either use the built-in HRTF database, or supply your own HRTF data at run-time.
IPLHrtfInterpolation	Techniques for interpolating HRTF data. This is used when rendering a point source whose position relative to the listener is not contained in the measured HRTF data used by Phonon.
IPLProbePlacement	The algorithm to use when generating a set of probes. Probes are generated by specifying a bounding box for a portion of the scene, and an algorithm for filling the volume of the box with probes. You can generate probes using different algorithms in different portions of a scene. The bounding boxes used for probe generation in different regions may overlap, although this is not typical.
IPLSceneType	The ray tracer to use for scene representation and simulation. Phonon lets you choose from multiple ray tracing implementations, each with different trade-offs. You can also choose to use your own ray tracing implementation.
IPLSimulationType	The type of simulation to perform. All sound sources must use the same type of simulation; it is not currently possible to use real-time simulation for some sources and baked data for others.
IPLbool	Boolean values.
IPLerror	Status codes returned by Phonon API functions.

Functions

iplAddProbeBatch⚠	Adds a Probe Batch to a Probe Manager object. Once this function returns, probes in the Probe Batch will be used to calculate sound propagation effects.
iplAddProbeToBatch⚠	Adds a specific probe from a Probe Box to a Probe Batch. Once all probes in a Probe Box have been assigned to their respective Probe Batches, you can destroy the Probe Box object; the baked data for the probes will be retained by the Probe Batch.
iplApplyAmbisonicsBinauralEffect⚠	Applies HRTF-based binaural rendering to a buffer of Ambisonics audio data. Ambisonics encoders and decoders use many different conventions to store the multiple Ambisonics channels, as well as different normalization schemes. Make sure that you correctly specify these settings when creating the Ambisonics Binaural Effect object, otherwise the rendered audio will be incorrect.
iplApplyAmbisonicsPanningEffect⚠	Applies a panning-based rendering algorithm to a buffer of Ambisonics audio data. Ambisonics encoders and decoders use many different conventions to store the multiple Ambisonics channels, as well as different normalization schemes. Make sure that you correctly specify these settings when creating the Ambisonics Panning Effect object, otherwise the rendered audio will be incorrect.
iplApplyBinauralEffect⚠	Applies HRTF-based binaural rendering to a buffer of audio data. The input audio is treated as emanating from a single point. If the input audio buffer contains more than one channel, it will automatically be downmixed to mono. Using bilinear interpolation (by setting \c interpolation to \c ::IPL_HRTFINTERPOLATION_BILINEAR) can incur a relatively high CPU cost. Use it only on sources where nearest-neighbor filtering (\c ::IPL_HRTFINTERPOLATION_NEAREST) produces suboptimal results. Typically, bilinear filtering is most useful for wide-band noise-like sounds, such as radio static, mechanical noise, fire, etc.
iplApplyBinauralEffectWithParameters⚠
iplApplyDirectSoundEffect⚠	Applies various parameters in \c IPLDirectSoundPath to a buffer of audio data.
iplApplyPanningEffect⚠	Applies 3D panning to a buffer of audio data, using the configuration of a Panning Effect object. The input audio is treated as emanating from a single point. If the input audio buffer contains more than one channel, it will automatically be downmixed to mono.
iplApplyVirtualSurroundEffect⚠	Applies HRTF-based binaural rendering to a buffer of multichannel audio data.
iplBakePropagation⚠	Bakes propagation effects from a specified source to all probes in a Probe Box. Sources are defined in terms of a position and a sphere of influence; all probes in the Probe Box that lie within the sphere of influence are processed by this function. This is a time-consuming operation, and should typically be called from the game engine's editor.
iplBakeReverb⚠	Bakes reverb at all probes in a Probe Box. Phonon defines reverb as the indirect sound received at a probe when a source is placed at the probe's location. This is a time-consuming operation, and should typically be called from the game engine's editor.
iplBakeStaticListener⚠	Bakes propagation effects from all probes in a Probe Box to a specified listener. Listeners are defined solely by their position; their orientation may freely change at run-time. This is a time-consuming operation, and should typically be called from the game engine's editor.
iplCalculateRelativeDirection⚠	Calculates the relative direction from the listener to a sound source. The returned direction vector is expressed in the listener's coordinate system.
iplCancelBake⚠	Cancels any bake operations that may be in progress. Typically, an application will call \c ::iplBakeReverb or \c ::iplBakePropagation in a separate thread from the editor's GUI thread, to keep the GUI responsive. This function can be called from the GUI thread to safely and prematurely terminate execution of any of these functions.
iplCleanup⚠	Performs last-minute cleanup and finalization. This function must be the last API function to be called before your application exits.
iplConvertAudioBufferFormat⚠	Converts the format of an audio buffer into the format of the output audio buffer. This is primarily useful for 360 video and audio authoring workflows. The following format conversions are supported:
iplCreateAmbisonicsBinauralEffect⚠	Creates an Ambisonics Binaural Effect object. This can be used to render higher-order Ambisonics data using HRTF-based binaural rendering.
iplCreateAmbisonicsPanningEffect⚠	Creates an Ambisonics Panning Effect object. This can be used to render higher-order Ambisonics data using standard panning algorithms.
iplCreateAmbisonicsRotator⚠	Creates an Ambisonics Rotator object. An Ambisonics Rotator object is used to apply an arbitrary rotation to audio data encoded in Ambisonics. This is primarily useful in the following situations:
iplCreateBinauralEffect⚠	Creates an Object-Based Binaural Effect object. This can be used to render a point source using HRTF-based binaural rendering.
iplCreateBinauralRenderer⚠	Creates a Binaural Renderer object. This function must be called before creating any Panning Effect objects, Object-Based Binaural Effect objects, Virtual Surround Effect objects, or Ambisonics Binaural Effect objects. Calling this function for the first time is somewhat expensive; avoid creating Binaural Renderer objects in your audio thread if at all possible. This function is not thread-safe. It cannot be simultaneously called from multiple threads.
iplCreateComputeDevice⚠	Creates a Compute Device object. The same Compute Device must be used by the game engine and audio engine parts of the Phonon integration. Depending on the OpenCL driver and device, this function may take some time to execute, so do not call it from performance-sensitive code.
iplCreateContext⚠	Creates a Context object. A Context object must be created before creating any other API objects.
iplCreateConvolutionEffect⚠	Creates a Convolution Effect object.
iplCreateDirectSoundEffect⚠	Creates a Direct Sound Effect object.
iplCreateEnvironment⚠	Creates an Environment object. It is necessary to call this function even if you are not using the sound propagation features of Phonon.
iplCreateEnvironmentalRenderer⚠	Creates an Environmental Renderer object.
iplCreatePanningEffect⚠	Creates a Panning Effect object. This can be used to render a point source on surround speakers, or using Ambisonics.
iplCreateProbeBatch⚠	Creates a Probe Batch object. A Probe Batch object represents a set of probes that are loaded and unloaded from memory as a unit when the game is played. A Probe Batch may contain probes from multiple Probe Boxes; multiple Probe Batches may contain probes from the same Probe Box. At run-time, Phonon does not use Probe Boxes, it only needs Probe Batches. The typical workflow is as follows:
iplCreateProbeBox⚠	Generates probes within a box. This function should typically be called from the game engine's editor, in response to the user indicating that they want to generate probes in the scene.
iplCreateProbeManager⚠	Creates a Probe Manager object. A Probe Manager object manages a set of Probe Batch objects are runtime. It is typically exported from the game engine to the audio engine via an Environment object. Probe Batch objects can be dynamically added to or removed from a Probe Manager object.
iplCreateScene⚠	Creates a Scene object. A Scene object does not store any geometry information on its own; for that you need to create one or more Static Mesh objects and add them to the Scene object. The Scene object does contain an array of materials; all triangles in all Static Mesh objects refer to this array in order to specify their material properties.
iplCreateSimulationData⚠	}
iplCreateStaticMesh⚠	Creates a Static Mesh object. A Static Mesh object represents a triangle mesh that does not change after it is created. A Static Mesh object also contains a mapping between each of its triangles and their acoustic material properties. Static Mesh objects should be used for scene geometry that is guaranteed to never change, such as rooms, buildings, or triangulated terrain. A Scene object may contain multiple Static Mesh objects, although typically one is sufficient.
iplCreateVirtualSurroundEffect⚠	Creates a Virtual Surround Effect object. This can be used to render a multichannel surround sound data using HRTF-based binaural rendering.
iplDeinterleaveAudioBuffer⚠	Deinterleaves an interleaved audio buffer. The formats of \c inputAudio and \c outputAudio must be identical except for the \c channelOrder field.
iplDeleteBakedDataByIdentifier⚠	Deletes all baked data in a Probe Box that is associated with a given source. If no such baked data exists, this function does nothing.
iplDestroyAmbisonicsBinauralEffect⚠	Destroys an Ambisonics Binaural Effect object.
iplDestroyAmbisonicsPanningEffect⚠	Destroys an Ambisonics Panning Effect object.
iplDestroyAmbisonicsRotator⚠	Destroys an Ambisonics Rotator object.
iplDestroyBinauralEffect⚠	Destroys an Object-Based Binaural Effect object.
iplDestroyBinauralRenderer⚠	Destroys a Binaural Renderer object. If any other API objects are still referencing the Binaural Renderer object, it will not be destroyed; destruction occurs when the object's reference count reaches zero.
iplDestroyComputeDevice⚠	Destroys a Compute Device object. If any other API objects are still referencing the Compute Device object, it will not be destroyed; destruction occurs when the object's reference count reaches zero.
iplDestroyContext⚠	Destroys a Context object. If any other API objects are still referencing the Context object, it will not be destroyed; destruction occurs when the Context object's reference count reaches zero.
iplDestroyConvolutionEffect⚠	Destroys a Convolution Effect object.
iplDestroyDirectSoundEffect⚠	Destroys a Direct Sound Effect object.
iplDestroyEnvironment⚠	Destroys an Environment object. If any other API objects are still referencing the Environment object, it will not be destroyed; destruction occurs when the object's reference count reaches zero.
iplDestroyEnvironmentalRenderer⚠	Destroys an Environmental Renderer object. If any other API objects are still referencing the Environmental Renderer object, the object will not be destroyed; it will only be destroyed once its reference count reaches zero.
iplDestroyPanningEffect⚠	Destroys a Panning Effect object.
iplDestroyProbeBatch⚠	Destroys a Probe Batch object.
iplDestroyProbeBox⚠	Destroys a Probe Box object.
iplDestroyProbeManager⚠	Destroys a Probe Manager object.
iplDestroyScene⚠	Destroys a Scene object. If any other API objects are still referencing the Scene object, it will not be destroyed; destruction occurs when the object's reference count reaches zero.
iplDestroySimulationData⚠
iplDestroyStaticMesh⚠	Destroys a Static Mesh object. If any other API objects are still referencing the Static Mesh object, it will not be destroyed; destruction occurs when the object's reference count reaches zero. Since the Scene object maintains an internal reference to the Static Mesh object, you may call this function at any point after fully specifying the Static Mesh object using \c ::iplSetStaticMeshVertices, \c ::iplSetStaticMeshTriangles, and \c ::iplSetStaticMeshMaterials.
iplDestroyVirtualSurroundEffect⚠	Destroys a Virtual Surround Effect object.
iplDumpSceneToObjFile⚠	Saves a Scene object to an OBJ file. An OBJ file is a widely-supported 3D model file format, that can be displayed using a variety of software on most PC platforms. The OBJ file generated by this function can be useful for detecting problems that occur when exporting scene data from the game engine to Phonon. The \c ::iplFinalizeScene function must have been called on the Scene object before calling this function. This function can only be called on a Scene object that has been created using the Phonon built-in ray tracer.
iplFinalizeProbeBatch⚠	Finalizes the set of probes that comprise a Probe Batch. Calling this function builds internal data structures that are used to rapidly determine which probes influence any given point in 3D space. You may not call \c ::iplAddProbeToBatch after calling this function. You must call this function before calling \c ::iplAddProbeBatch to add this Probe Batch object to a Probe Manager object.
iplFinalizeScene⚠	Finalizes a scene and builds internal data structures. Once this function is called, you may not modify the Scene object or any Static Mesh objects it contains in any way. This function results in various internal data structures being generated; if using Radeon Rays, it results in scene data being uploaded to the GPU. This is a time-consuming, blocking call, so do not call it from performance-sensitive code.
iplFlushAmbisonicsBinauralEffect⚠	Resets any internal state maintained by an Ambisonics Binaural Effect object. This is useful if the Ambisonics Binaural Effect object is going to be disabled/unused for a few frames; resetting the internal state will prevent an audible glitch when the Ambisonics Binaural Effect object is re-enabled at a later time.
iplFlushAmbisonicsPanningEffect⚠	Resets any internal state maintained by an Ambisonics Panning Effect object. This is useful if the Ambisonics Panning Effect object is going to be disabled/unused for a few frames; resetting the internal state will prevent an audible glitch when the Ambisonics Panning Effect object is re-enabled at a later time.
iplFlushBinauralEffect⚠	Resets any internal state maintained by an Object-Based Binaural Effect object. This is useful if the Object-Based Binaural Effect object is going to be disabled/unused for a few frames; resetting the internal state will prevent an audible glitch when the Object-Based Binaural Effect object is re-enabled at a later time.
iplFlushConvolutionEffect⚠	Resets any internal state maintained by a Convolution Effect object. This is useful if the Convolution Effect object is going to be disabled/unused for a few frames; resetting the internal state will prevent an audible glitch when the Convolution Effect object is re-enabled at a later time.
iplFlushDirectSoundEffect⚠	Resets any internal state maintained by a Direct Sound Effect object. This is useful if the Direct Sound Effect object is going to be disabled/unused for a few frames; resetting the internal state will prevent an audible glitch when the Direct Sound Effect object is re-enabled at a later time.
iplFlushPanningEffect⚠	Resets any internal state maintained by a Panning Effect object. This is useful if the Panning Effect object is going to be disabled/unused for a few frames; resetting the internal state will prevent an audible glitch when the Panning Effect object is re-enabled at a later time.
iplFlushVirtualSurroundEffect⚠	Resets any internal state maintained by a Virtual Surround Effect object. This is useful if the Virtual Surround Effect object is going to be disabled/unused for a few frames; resetting the internal state will prevent an audible glitch when the Virtual Surround Effect object is re-enabled at a later time.
iplGenerateSimulationData⚠
iplGetBakedDataSizeByIdentifier⚠	Returns the size (in bytes) of the baked data stored in a Probe Box corresponding to a given source. This is useful for displaying statistics in the editor's GUI.
iplGetDirectSoundPath⚠	Calculates direct sound path parameters for a single source. It is up to the audio engine to perform audio processing that uses the information returned by this function.
iplGetMixedEnvironmentalAudio⚠	Retrieves a mixed frame of wet audio. This is the sum of all wet audio data from all Convolution Effect objects that were created using the given Environmental Renderer object. Unless using TrueAudio Next for convolution, this is likely to provide a significant performance boost to the audio thread as compared to calling \c ::iplGetWetAudioForConvolutionEffect for each Convolution Effect separately. On the other hand, doing so makes it impossible to apply additional DSP effects for specific sources before mixing.
iplGetNumIrChannels⚠
iplGetNumIrSamples⚠
iplGetProbeSpheres⚠	Retrieves spheres describing the positions and influence radii of all probes in the Probe Box object. This function should typically be called from the game engine's editor, and the retrieved spheres should be used for visualization.
iplGetSimulationResult⚠
iplGetWetAudioForConvolutionEffect⚠	Retrieves a frame of wet audio from a Convolution Effect object. This is the result of applying sound propagation effects to the dry audio previously specified using \c ::iplSetDryAudioForConvolutionEffect.
iplInterleaveAudioBuffer⚠	Interleaves a deinterleaved audio buffer. The formats of \c inputAudio and \c outputAudio must be identical except for the \c channelOrder field.
iplLoadFinalizedScene⚠	Creates a Scene object based on data stored in a byte array. After this function is called, it is not necessary to call \c ::iplFinalizeScene on the resulting Scene object.
iplLoadProbeBatch⚠	Deserializes a Probe Batch object from a byte array. This is typically called by the game engine's editor when loading a Probe Batch object from disk. Calling this function implicitly calls \c ::iplFinalizeProbeBatch, so you do not need to call it explicitly.
iplLoadProbeBox⚠	Deserializes a Probe Box object from a byte array. This is typically called by the game engine's editor when loading a Probe Box object from disk.
iplMixAudioBuffers⚠	Mixes a set of audio buffers. This is primarily useful for mixing the output of multiple Panning Effect objects, before passing them to a single Virtual Surround Effect or a single Ambisonics Binaural Effect. This way, applications can significantly accelerate 3D audio rendering for large numbers of sources.
iplRemoveProbeBatch⚠	Removes a Probe Batch from a Probe Manager object. Once this function returns, probes in the Probe Batch will no longer be used to calculate sound propagation effects.
iplRotateAmbisonicsAudioBuffer⚠	Rotates an Ambisonics-encoded audio buffer. The \c ::iplSetAmbisonicsRotation function must have been called prior to calling this function, or the resulting audio will be incorrect. It is possible to pass the same value for \c inputAudio and \c outputAudio. This results in in-place rotation of the Ambisonics data.
iplSaveFinalizedScene⚠	Serializes a Scene object to a byte array. The \c ::iplFinalizeScene function must have been called on the Scene object before calling this function. This function can only be called on a Scene object that has been created using the Phonon built-in ray tracer.
iplSaveProbeBatch⚠	Serializes a Probe Batch object to a byte array. This is typically called by the game engine's editor in order to save the Probe Batch object's data to disk.
iplSaveProbeBox⚠	Serializes a Probe Box object to a byte array. This is typically called by the game engine's editor in order to save the Probe Box object's data to disk.
iplSetAmbisonicsRotation⚠	Specifies a rotation value. This function must be called before using \c ::iplRotateAmbisonicsAudioBuffer to rotate an Ambisonics-encoded audio buffer, or the resulting audio will be incorrect.
iplSetConvolutionEffectIdentifier⚠	Changes the identifier associated with a Convolution Effect object. This is useful when using a static listener bake, where you may want to teleport the listener between two or more locations for which baked data has been generated.
iplSetDryAudioForConvolutionEffect⚠	Specifies a frame of dry audio for a Convolution Effect object. This is the audio data to which sound propagation effects should be applied.
iplSetNumBounces⚠	Sets the number of bounces to use for real-time simulations that use an Environment object. Calling this function overrides the value of \c bounces set on the \c IPLSimulationSettings structure passed when calling \c ::iplCreateEnvironment to create this Environment object.
iplSetRayTracerCallbacks⚠	Specifies callbacks that allow a Scene object to call into a user-specified custom ray tracer. This function should only be called if using a custom ray tracer, or else undefined behavior will occur. When using a custom ray tracer, this function must be called before any simulation occurs, otherwise undefined behavior will occur.
iplSetSceneMaterial⚠	Specifies a single material used by a Scene object. All materials must be completely specified before simulation occurs, otherwise simulation results will be incorrect.
iplSetStaticMeshMaterials⚠	Specifies the materials associated with each triangle in a Static Mesh object. Material indices passed using this function refer to the array containing material data passed to \c ::iplSetSceneMaterial.
iplSetStaticMeshTriangles⚠	Specifies the triangles of a Static Mesh object. Triangle indices passed using this function refer to the vertex array passed using \c ::iplSetStaticMeshVertices.
iplSetStaticMeshVertices⚠	Specifies the vertices of a Static Mesh object. All vertices must be converted from the game engine's coordinate system to Phonon's coordinate system before being passed to this function.

Type Definitions

IPLAllocateFunction	Prototype of a callback that allocates memory. This is usually specified to let Phonon use a custom memory allocator. The default behavior is to use the OS-dependent aligned version of \c malloc.
IPLAnyHitCallback	A callback that is called to calculate whether a ray hits any geometry. Strictly speaking, the function looks for any intersection with a ray interval (equivalent to a line segment).
IPLBakeProgressCallback	A callback that is called to update the application on the progress of the \c ::iplBakeReverb or \c ::iplBakePropagation functions. You can use this to provide visual feedback to the user, like a progress bar.
IPLClosestHitCallback	A callback that is called to calculate the closest hit along a ray. Strictly speaking, the intersection is calculated with a ray interval (equivalent to a line segment). Any ray interval may have multiple points of intersection with scene geometry; this function must return information about the point of intersection that is closest to the ray's origin.
IPLFftHelper	A function that you can call to calculate the Fast Fourier Transform (FFT) of a real-valued time-domain signal. You will typically call this from within your implementation of IPLHrtfLoadCallback, to transform your time-domain Head-Related Impulse Responses (HRIRs) into Head-Related Transfer Functions (HRTFs).
IPLFinalizeSceneProgressCallback	A callback that is called to update the application on the progress of the iplFinalizeScene function. You can use this to provide the user with visual feedback, like a progress bar.
IPLFreeFunction	Prototype of a callback that frees a block of memory. This is usually specified when using a custom memory allocator with Phonon. The default behavior is to use the OS-dependent aligned version of \c free.
IPLHrtfLoadCallback	Pointer to a function that will be called during the execution of iplCreateBinauralRenderer, to allow your application to pre-transform all HRTF data into frequency domain.
IPLHrtfLookupCallback	Pointer to a function that will be called during the execution of iplApplyBinauralEffect, to left your application copy HRTF data for a given direction into arrays managed by Phonon.
IPLHrtfUnloadCallback	Pointer to a function that will be called during the execution of iplDestroyBinauralRenderer, to allow your application to free memory allocated during IPLHrtfLoadCallback.
IPLLoadSceneProgressCallback	A callback that is called to update the application on the progress of the iplLoadScene function. You can use this to provide the user with visual feedback, like a progress bar.
IPLLogFunction	Prototype of a callback that logs a message generated by Phonon. This may be implemented in any suitable way, such as appending to a log file, displaying a dialog box, etc. The default behavior is to print to \c stdout.
IPLProbePlacementProgressCallback	A callback that is called to update the application on the progress of the \c ::iplCreateProbeBox function. You can use this to provide visual feedback to the user, like a progress bar.
IPLSimulationThreadCreateCallback	Callback function that is called when the simulation thread is created.
IPLSimulationThreadDestroyCallback	Callback function that is called when the simulation thread is destroyed.
IPLbyte
IPLfloat32
IPLfloat64
IPLhandle	An opaque handle to a Phonon API object. A variable of this type may not be cast to a pointer to any other API type.
IPLint8
IPLint16
IPLint32
IPLint64
IPLsize
IPLstring
IPLuint8
IPLuint16
IPLuint32
IPLuint64
IPLvoid	\defgroup types Data Types Common data types used throughout the Phonon API. {
wchar_t