Table of Contents

include/AK/SoundEngine/Common/AkSoundEngine.h

Go to the documentation of this file.
00001 /*******************************************************************************
00002 The content of this file includes portions of the AUDIOKINETIC Wwise Technology
00003 released in source code form as part of the SDK installer package.
00004 
00005 Commercial License Usage
00006 
00007 Licensees holding valid commercial licenses to the AUDIOKINETIC Wwise Technology
00008 may use this file in accordance with the end user license agreement provided 
00009 with the software or, alternatively, in accordance with the terms contained in a
00010 written agreement between you and Audiokinetic Inc.
00011 
00012 Apache License Usage
00013 
00014 Alternatively, this file may be used under the Apache License, Version 2.0 (the 
00015 "Apache License"); you may not use this file except in compliance with the 
00016 Apache License. You may obtain a copy of the Apache License at 
00017 http://www.apache.org/licenses/LICENSE-2.0.
00018 
00019 Unless required by applicable law or agreed to in writing, software distributed
00020 under the Apache License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES
00021 OR CONDITIONS OF ANY KIND, either express or implied. See the Apache License for
00022 the specific language governing permissions and limitations under the License.
00023 
00024   Version: <VERSION>  Build: <BUILDNUMBER>
00025   Copyright (c) <COPYRIGHTYEAR> Audiokinetic Inc.
00026 *******************************************************************************/
00027 
00028 // AkSoundEngine.h
00029 
00030 /// \file 
00031 /// The main sound engine interface.
00032 
00033 
00034 #ifndef _AK_SOUNDENGINE_H_
00035 #define _AK_SOUNDENGINE_H_
00036 
00037 #include <AK/SoundEngine/Common/AkSoundEngineExport.h>
00038 #include <AK/SoundEngine/Common/AkTypes.h>
00039 #include <AK/SoundEngine/Common/IAkPlugin.h>
00040 #include <AK/SoundEngine/Common/AkCallback.h>
00041 
00042 #ifdef AK_WIN
00043 #include <AK/SoundEngine/Platforms/Windows/AkWinSoundEngine.h>
00044 
00045 #elif defined (AK_MAC_OS_X)
00046 #include <AK/SoundEngine/Platforms/Mac/AkMacSoundEngine.h>
00047 
00048 #elif defined (AK_IOS)
00049 #include <AK/SoundEngine/Platforms/iOS/AkiOSSoundEngine.h>
00050 
00051 #elif defined (AK_XBOXONE)
00052 #include <AK/SoundEngine/Platforms/XboxOne/AkXboxOneSoundEngine.h>
00053 
00054 #elif defined( AK_LUMIN )
00055 #include <AK/SoundEngine/Platforms/Lumin/AkLuminSoundEngine.h>
00056 
00057 #elif defined( AK_ANDROID )
00058 #include <AK/SoundEngine/Platforms/Android/AkAndroidSoundEngine.h>
00059 
00060 #elif defined (AK_PS4)
00061 #include <AK/SoundEngine/Platforms/PS4/AkPS4SoundEngine.h>
00062 
00063 #elif defined( AK_GGP )
00064 #include <AK/SoundEngine/Platforms/GGP/AkGGPSoundEngine.h>
00065 
00066 #elif defined( AK_LINUX_DESKTOP )
00067 #include <AK/SoundEngine/Platforms/Linux/AkLinuxSoundEngine.h>
00068 
00069 #elif defined( AK_EMSCRIPTEN )
00070 #include <AK/SoundEngine/Platforms/Emscripten/AkEmscriptenSoundEngine.h>
00071 
00072 #elif defined( AK_QNX  )
00073 #include <AK/SoundEngine/Platforms/QNX/AkQNXSoundEngine.h>
00074 
00075 #elif defined( AK_NX )
00076 #include <AK/SoundEngine/Platforms/NX/AkNXSoundEngine.h>
00077 
00078 #else
00079 #error AkSoundEngine.h: Undefined platform
00080 #endif
00081 
00082 #ifndef AK_ASSERT_HOOK
00083     /// Function called on assert handling, optional
00084     /// \sa 
00085     /// - AkInitSettings
00086     AK_CALLBACK( void, AkAssertHook)( 
00087         const char * in_pszExpression,  ///< Expression
00088         const char * in_pszFileName,    ///< File Name
00089         int in_lineNumber               ///< Line Number
00090         );
00091     #define AK_ASSERT_HOOK
00092 #endif
00093 
00094 /// Callback function prototype for User Music notifications
00095 /// It is useful for reacting to user music playback.
00096 ///
00097 /// \sa
00098 /// - \ref AkGlobalCallbackFunc
00099 /// - \ref AK::SoundEngine::iOS::AudioInterruptionCallbackFunc
00100 /// - \ref AkPlatformInitSettings
00101 /// - \ref background_music_and_dvr
00102 ///
00103 typedef AKRESULT ( * AkBackgroundMusicChangeCallbackFunc )(
00104     bool in_bBackgroundMusicMuted,  ///< Flag indicating whether the busses tagged as "background music" in the project are muted or not.
00105     void* in_pCookie ///< User-provided data, e.g. a user structure.
00106     );
00107 
00108 /// Platform-independent initialization settings of output devices.
00109 struct AkOutputSettings
00110 {
00111     AkOutputSettings() :
00112         audioDeviceShareset(AK_INVALID_UNIQUE_ID),      
00113         idDevice(0),        
00114         ePanningRule(AkPanningRule_Speakers),
00115         channelConfig(){};
00116 
00117     AkOutputSettings(const char* in_szDeviceShareSet, AkUniqueID in_idDevice = AK_INVALID_UNIQUE_ID, AkChannelConfig in_channelConfig = AkChannelConfig(), AkPanningRule in_ePanning = AkPanningRule_Speakers);     
00118 
00119 #ifdef AK_SUPPORT_WCHAR
00120     AkOutputSettings(const wchar_t* in_szDeviceShareSet, AkUniqueID in_idDevice = AK_INVALID_UNIQUE_ID, AkChannelConfig in_channelConfig = AkChannelConfig(), AkPanningRule in_ePanning = AkPanningRule_Speakers);
00121 #endif
00122 
00123     AkUniqueID      audioDeviceShareset;    ///< Unique ID of a custom audio device to be used. Custom audio devices are defined in the Audio Device Shareset section of the Wwise project.
00124                                             ///< If you want to output normally through the default system, leave this field to its default value (AK_INVALID_UNIQUE_ID).
00125                                             ///< Typical usage: AkInitSettings.eOutputSettings.audioDeviceShareset = AK::SoundEngine::GetIDFromString("InsertYourAudioDeviceSharesetNameHere");
00126                                             /// \sa <tt>\ref AK::SoundEngine::GetIDFromString()</tt>
00127                                             /// \sa \ref soundengine_plugins_audiodevices
00128                                             /// \sa \ref integrating_secondary_outputs
00129                                             /// \sa \ref default_audio_devices
00130 
00131     AkUInt32        idDevice;               ///< Device specific identifier, when multiple devices of the same type are possible.  If only one device is possible, leave to 0.
00132                                             ///< - PS4 Controller-Speakers: UserID as returned from sceUserServiceGetLoginUserIdList
00133                                             ///< - XBoxOne Controller-Headphones: Use the AK::GetDeviceID function to get the ID from an IMMDevice. Find the player's device with the WASAPI API (IMMDeviceEnumerator, see Microsoft documentation) or use AK::GetDeviceIDFromName.                                         
00134                                             ///< - Windows: Use AK::GetDeviceID or AK::GetDeviceIDFromName to get the correct ID.  Leave to 0 for the default Windows device as seen in Audio Properties.
00135                                             ///< - All other outputs: use 0 to select the default for the selected audio device type (shareset) 
00136 
00137     AkPanningRule   ePanningRule;           ///< Rule for 3D panning of signals routed to a stereo bus. In AkPanningRule_Speakers mode, the angle of the front loudspeakers 
00138                                             ///< (uSpeakerAngles[0]) is used. In AkPanningRule_Headphones mode, the speaker angles are superseded with constant power panning
00139                                             ///< between two virtual microphones spaced 180 degrees apart.
00140 
00141     AkChannelConfig channelConfig;          ///< Channel configuration for this output. Call AkChannelConfig::Clear() to let the engine use the default output configuration.  
00142                                             ///< Hardware might not support the selected configuration.
00143 };
00144 
00145 /// Possible values for the floor plane axis used in the Game Object 3D Viewer in Wwise
00146 enum AkFloorPlane
00147 {
00148     AkFloorPlane_XZ = 0,
00149     AkFloorPlane_XY,
00150     AkFloorPlane_YZ,
00151     AkFloorPlane_Default = AkFloorPlane_XZ
00152 };
00153 
00154 /// The execution context for a task.
00155 struct AkTaskContext
00156 {
00157     AkUInt32 uIdxThread;           ///< The current thread index [0, AkTaskSchedulerDesc::uNumSchedulerWorkerThreads[.
00158 };
00159 
00160 /// Task function: process the [in_uIdxBegin,in_uIdxEnd[ range of items in the in_pData array.
00161 typedef void(*AkParallelForFunc)(void* in_pData, AkUInt32 in_uIdxBegin, AkUInt32 in_uIdxEnd, AkTaskContext in_ctx, void* in_pUserData);
00162 
00163 /// Description of the client task scheduler.
00164 struct AkTaskSchedulerDesc
00165 {
00166     /// Execute in_func in parallel over the [in_uIdxBegin,in_uIdxEnd[ range of items in the in_pData array,
00167     /// and wait for the work to finish.
00168     typedef void(*ParallelForFunc)(
00169         void * in_pData,            ///< A pointer to a data array.
00170         AkUInt32 in_uIdxBegin,     ///< The first element of data to process.
00171         AkUInt32 in_uIdxEnd,       ///< The one past the last element of data to process.
00172         AkUInt32 in_uTileSize,     ///< The desired maximum tile size in which to subdivide the data.
00173         AkParallelForFunc in_func, ///< The data processing function.
00174         void * in_pUserData,       ///< User data to be passed into 'func'.
00175         const char * in_szDebugName);    ///< Debug name for the workload.
00176 
00177     ParallelForFunc fcnParallelFor;             ///< ParallelForFunc callback.
00178     AkUInt32        uNumSchedulerWorkerThreads; ///< The number of worker threads in the schduler.
00179 };
00180 
00181 /// Platform-independent initialization settings of the sound engine
00182 /// \sa 
00183 /// - <tt>AK::SoundEngine::Init()</tt>
00184 /// - <tt>AK::SoundEngine::GetDefaultInitSettings()</tt>
00185 /// - \ref soundengine_integration_init_advanced
00186 /// - \ref soundengine_initialization_advanced_soundengine_using_memory_threshold
00187 struct AkInitSettings
00188 {
00189     AkAssertHook        pfnAssertHook;              ///< External assertion handling function (optional)
00190 
00191     AkUInt32            uMaxNumPaths;               ///< Maximum number of paths for positioning
00192     AkUInt32            uDefaultPoolSize;           ///< Size of the default memory pool, in bytes
00193     AkReal32            fDefaultPoolRatioThreshold; ///< 0.0f to 1.0f value: The percentage of occupied memory where the sound engine should enter in Low memory Mode. \ref soundengine_initialization_advanced_soundengine_using_memory_threshold
00194     AkUInt32            uCommandQueueSize;          ///< Size of the command queue, in bytes
00195     AkMemPoolId         uPrepareEventMemoryPoolID;  ///< Memory pool where data allocated by <tt>AK::SoundEngine::PrepareEvent()</tt> and <tt>AK::SoundEngine::PrepareGameSyncs()</tt> will be done. 
00196     bool                bEnableGameSyncPreparation; ///< Sets to true to enable AK::SoundEngine::PrepareGameSync usage.
00197     AkUInt32            uContinuousPlaybackLookAhead;   ///< Number of quanta ahead when continuous containers should instantiate a new voice before which next sounds should start playing. This look-ahead time allows I/O to occur, and is especially useful to reduce the latency of continuous containers with trigger rate or sample-accurate transitions. 
00198                                                     ///< Default is 1 audio quantum, also known as an audio frame. Its size is equal to AkInitSettings::uNumSamplesPerFrame / AkPlatformInitSettings::uSampleRate. For many platforms the default values - which can be overridden - are respectively 1,024 samples and 48 kHz. This gives a default 21.3 ms for an audio quantum, which is adequate if you have a RAM-based streaming device that completes transfers within 20 ms. With 1 look-ahead quantum, voices spawned by continuous containers are more likely to be ready when they are required to play, thereby improving the overall precision of sound scheduling. If your device completes transfers in 30 ms instead, you might consider increasing this value to 2 because it will grant new voices 2 audio quanta (~43 ms) to fetch data. 
00199 
00200     AkUInt32            uNumSamplesPerFrame;        ///< Number of samples per audio frame (256, 512, 1024, or 2048).
00201 
00202     AkUInt32            uMonitorPoolSize;           ///< Size of the monitoring pool, in bytes. This parameter is not used in Release build.
00203     AkUInt32            uMonitorQueuePoolSize;      ///< Size of the monitoring queue pool, in bytes. This parameter is not used in Release build.
00204     
00205     AkOutputSettings    settingsMainOutput;         ///< Main output device settings.
00206     AkUInt32            uMaxHardwareTimeoutMs;      ///< Amount of time to wait for HW devices to trigger an audio interrupt. If there is no interrupt after that time, the sound engine will revert to  silent mode and continue operating until the HW finally comes back. Default value: 2000 (2 seconds)
00207 
00208     bool                bUseSoundBankMgrThread;     ///< Use a separate thread for loading sound banks. Allows asynchronous operations.
00209     bool                bUseLEngineThread;          ///< Use a separate thread for processing audio. If set to false, audio processing will occur in RenderAudio(). \ref goingfurther_eventmgrthread
00210 
00211     AkBackgroundMusicChangeCallbackFunc BGMCallback; ///< Application-defined audio source change event callback function.
00212     void*               BGMCallbackCookie;          ///< Application-defined user data for the audio source change event callback function.
00213     AkOSChar *          szPluginDLLPath;            ///< When using DLLs for plugins, specify their path. Leave NULL if DLLs are in the same folder as the game executable.
00214 
00215     AkFloorPlane        eFloorPlane;                ///< Floor plane axis for 3D game object viewing.
00216     AkTaskSchedulerDesc taskSchedulerDesc;          ///< The defined client task scheduler that AkSoundEngine will use to schedule internal tasks.
00217 };
00218 
00219 /// Necessary settings for setting externally-loaded sources
00220 struct AkSourceSettings
00221 {
00222     AkUniqueID  sourceID;                           ///< Source ID (available in the SoundBank content files)
00223     AkUInt8*    pMediaMemory;                       ///< Pointer to the data to be set for the source
00224     AkUInt32    uMediaSize;                         ///< Size, in bytes, of the data to be set for the source
00225 };
00226 
00227 /// Return values for GetSourcePlayPositions.
00228 struct AkSourcePosition
00229 {
00230     AkUniqueID  audioNodeID;                        ///< Audio Node ID of playing item
00231     AkUniqueID  mediaID;                            ///< Media ID of playing item. (corresponds to 'ID' attribute of 'File' element in SoundBank metadata file)
00232     AkTimeMs    msTime;                             ///< Position of the source (in ms) associated with that playing item
00233 };
00234 
00235 /// Audiokinetic namespace
00236 namespace AK
00237 {
00238     class IReadBytes;
00239     class IWriteBytes;
00240 
00241     /// Audiokinetic sound engine namespace
00242     /// \remarks The functions in this namespace are thread-safe, unless stated otherwise.
00243     namespace SoundEngine
00244     {
00245         ///////////////////////////////////////////////////////////////////////
00246         /// @name Initialization
00247         //@{
00248 
00249         /// Query whether or not the sound engine has been successfully initialized.
00250         /// \warning This function is not thread-safe. It should not be called at the same time as \c SoundEngine::Init() or \c SoundEngine::Term().
00251         /// \return \c True if the sound engine has been initialized, \c False otherwise.
00252         /// \sa
00253         /// - \ref soundengine_integration_init_advanced
00254         /// - <tt>AK::SoundEngine::Init()</tt>
00255         /// - <tt>AK::SoundEngine::Term()</tt>
00256         AK_EXTERNAPIFUNC( bool, IsInitialized )();
00257 
00258         /// Initialize the sound engine.
00259         /// \warning This function is not thread-safe.
00260         /// \remark The initial settings should be initialized using <tt>AK::SoundEngine::GetDefaultInitSettings()</tt>
00261         ///         and <tt>AK::SoundEngine::GetDefaultPlatformInitSettings()</tt> to fill the structures with their 
00262         ///         default settings. This is not mandatory, but it helps avoid backward compatibility problems.
00263         ///     
00264         /// \return 
00265         /// - AK_Success if the initialization was successful
00266         /// - AK_MemManagerNotInitialized if the memory manager is not available or not properly initialized
00267         /// - AK_StreamMgrNotInitialized if the stream manager is not available or not properly initialized
00268         /// - AK_SSEInstructionsNotSupported if the machine does not support SSE instruction (only on the PC)
00269         /// - AK_InsufficientMemory or AK_Fail if there is not enough memory available to initialize the sound engine properly
00270         /// - AK_InvalidParameter if some parameters are invalid
00271         /// - AK_Fail if the sound engine is already initialized, or if the provided settings result in insufficient 
00272         /// resources for the initialization.
00273         /// \sa
00274         /// - \ref soundengine_integration_init_advanced
00275         /// - <tt>AK::SoundEngine::Term()</tt>
00276         /// - <tt>AK::SoundEngine::GetDefaultInitSettings()</tt>
00277         /// - <tt>AK::SoundEngine::GetDefaultPlatformInitSettings()</tt>
00278         AK_EXTERNAPIFUNC( AKRESULT, Init )(
00279             AkInitSettings *            in_pSettings,           ///< Initialization settings (can be NULL, to use the default values)
00280             AkPlatformInitSettings *    in_pPlatformSettings    ///< Platform-specific settings (can be NULL, to use the default values)
00281             );
00282 
00283         /// Gets the default values of the platform-independent initialization settings.
00284         /// \warning This function is not thread-safe.
00285         /// \sa
00286         /// - \ref soundengine_integration_init_advanced
00287         /// - <tt>AK::SoundEngine::Init()</tt>
00288         /// - <tt>AK::SoundEngine::GetDefaultPlatformInitSettings()</tt>
00289         AK_EXTERNAPIFUNC( void, GetDefaultInitSettings )(
00290             AkInitSettings &            out_settings            ///< Returned default platform-independent sound engine settings
00291             );
00292 
00293         /// Gets the default values of the platform-specific initialization settings.
00294         ///
00295         /// Windows Specific:
00296         ///     When initializing for Windows platform, the HWND value returned in the 
00297         ///     AkPlatformInitSettings structure is the foreground HWND at the moment of the 
00298         ///     initialization of the sound engine and may not be the correct one for your need.
00299         ///     Each game must specify the HWND that will be passed to DirectSound initialization.
00300         ///     It is required that each game provides the correct HWND to be used or it could cause
00301         ///     one of the following problem:
00302         ///             - Random Sound engine initialization failure.
00303         ///             - Audio focus to be located on the wrong window.
00304         ///
00305         /// \warning This function is not thread-safe.
00306         /// \sa 
00307         /// - \ref soundengine_integration_init_advanced
00308         /// - <tt>AK::SoundEngine::Init()</tt>
00309         /// - <tt>AK::SoundEngine::GetDefaultInitSettings()</tt>
00310         AK_EXTERNAPIFUNC( void, GetDefaultPlatformInitSettings )(
00311             AkPlatformInitSettings &    out_platformSettings    ///< Returned default platform-specific sound engine settings
00312             );
00313         
00314         /// Terminates the sound engine.
00315         /// If some sounds are still playing or events are still being processed when this function is 
00316         /// called, they will be stopped.
00317         /// \warning This function is not thread-safe.
00318         /// \warning Before calling Term, you must ensure that no other thread is accessing the sound engine.
00319         /// \sa 
00320         /// - \ref soundengine_integration_init_advanced
00321         /// - <tt>AK::SoundEngine::Init()</tt>
00322         AK_EXTERNAPIFUNC( void, Term )();
00323 
00324         /// Gets the configured audio settings.
00325         /// Call this function to get the configured audio settings.
00326         /// 
00327         /// \warning This function is not thread-safe.
00328         /// \warning Call this function only after the sound engine has been properly initialized.
00329         AK_EXTERNAPIFUNC( AKRESULT, GetAudioSettings )(
00330             AkAudioSettings &   out_audioSettings   ///< Returned audio settings
00331             );
00332 
00333         /// Gets the output speaker configuration of the specified output.
00334         /// Call this function to get the speaker configuration of the output (which may not correspond
00335         /// to the physical output format of the platform, in the case of downmixing provided by the platform itself). 
00336         /// You may initialize the sound engine with a user-specified configuration, but the resulting 
00337         /// configuration is determined by the sound engine, based on the platform, output type and
00338         /// platform settings (for e.g. system menu or control panel option). 
00339         /// 
00340         /// \warning Call this function only after the sound engine has been properly initialized. If you are initializing the sound engine with AkInitSettings::bUseLEngineThread to false, it is required to call RenderAudio() at least once before calling this function to complete the sound engine initialization.
00341         /// \return The output configuration. An empty AkChannelConfig (!AkChannelConfig::IsValid()) if device does not exist.
00342         /// \sa 
00343         /// - AkSpeakerConfig.h
00344         /// - AkOutputSettings
00345         AK_EXTERNAPIFUNC( AkChannelConfig, GetSpeakerConfiguration )(
00346             AkOutputDeviceID    in_idOutput = 0             ///< Output ID to set the bus on.  As returned from AddOutput or GetOutputID.  You can pass 0 for the main (default) output 
00347             );
00348 
00349         /// Gets the panning rule of the specified output.
00350         /// \warning Call this function only after the sound engine has been properly initialized.
00351         /// \return One of the supported configuration: 
00352         /// - AkPanningRule_Speakers
00353         /// - AkPanningRule_Headphone
00354         /// \sa 
00355         /// - AkSpeakerConfig.h
00356         AK_EXTERNAPIFUNC( AKRESULT, GetPanningRule )(
00357             AkPanningRule &     out_ePanningRule,           ///< Returned panning rule (AkPanningRule_Speakers or AkPanningRule_Headphone) for given output.
00358             AkOutputDeviceID    in_idOutput = 0             ///< Output ID to set the bus on.  As returned from AddOutput or GetOutputID.  You can pass 0 for the main (default) output 
00359             );
00360 
00361         /// Sets the panning rule of the specified output.
00362         /// This may be changed anytime once the sound engine is initialized.
00363         /// \warning This function posts a message through the sound engine's internal message queue, whereas GetPanningRule() queries the current panning rule directly.
00364         AK_EXTERNAPIFUNC( AKRESULT, SetPanningRule )( 
00365             AkPanningRule       in_ePanningRule,            ///< Panning rule.
00366             AkOutputDeviceID    in_idOutput = 0             ///< Output ID to set the bus on.  As returned from AddOutput or GetOutputID.  You can pass 0 for the main (default) output 
00367             );
00368 
00369         /// Gets speaker angles of the specified device. Speaker angles are used for 3D positioning of sounds over standard configurations.
00370         /// Note that the current version of Wwise only supports positioning on the plane.
00371         /// The speaker angles are expressed as an array of loudspeaker pairs, in degrees, relative to azimuth ]0,180].
00372         /// Supported loudspeaker setups are always symmetric; the center speaker is always in the middle and thus not specified by angles.
00373         /// Angles must be set in ascending order. 
00374         /// You may call this function with io_pfSpeakerAngles set to NULL to get the expected number of angle values in io_uNumAngles, 
00375         /// in order to allocate your array correctly. You may also obtain this number by calling
00376         /// AK::GetNumberOfAnglesForConfig( AK_SPEAKER_SETUP_DEFAULT_PLANE ).
00377         /// If io_pfSpeakerAngles is not NULL, the array is filled with up to io_uNumAngles.
00378         /// Typical usage:
00379         /// - AkUInt32 uNumAngles;
00380         /// - GetSpeakerAngles( NULL, uNumAngles, AkOutput_Main );
00381         /// - AkReal32 * pfSpeakerAngles = AkAlloca( uNumAngles * sizeof(AkReal32) );
00382         /// - GetSpeakerAngles( pfSpeakerAngles, uNumAngles, AkOutput_Main );
00383         /// \aknote 
00384         /// On most platforms, the angle set on the plane consists of 3 angles, to account for 7.1. 
00385         /// - When panning to stereo (speaker mode, see <tt>AK::SoundEngine::SetPanningRule()</tt>), only angle[0] is used, and 3D sounds in the back of the listener are mirrored to the front. 
00386         /// - When panning to 5.1, the front speakers use angle[0], and the surround speakers use (angle[2] - angle[1]) / 2.
00387         /// \endaknote
00388         /// \warning Call this function only after the sound engine has been properly initialized.
00389         /// \return AK_Success if device exists.
00390         /// \sa SetSpeakerAngles()
00391         AK_EXTERNAPIFUNC( AKRESULT, GetSpeakerAngles )(
00392             AkReal32 *          io_pfSpeakerAngles,         ///< Returned array of loudspeaker pair angles, in degrees relative to azimuth [0,180]. Pass NULL to get the required size of the array.
00393             AkUInt32 &          io_uNumAngles,              ///< Returned number of angles in io_pfSpeakerAngles, which is the minimum between the value that you pass in, and the number of angles corresponding to AK::GetNumberOfAnglesForConfig( AK_SPEAKER_SETUP_DEFAULT_PLANE ), or just the latter if io_pfSpeakerAngles is NULL.
00394             AkReal32 &          out_fHeightAngle,           ///< Elevation of the height layer, in degrees relative to the plane [-90,90].
00395             AkOutputDeviceID    in_idOutput = 0             ///< Output ID to set the bus on.  As returned from AddOutput or GetOutputID.  You can pass 0 for the main (default) output         
00396             );
00397         
00398         /// Sets speaker angles of the specified device. Speaker angles are used for 3D positioning of sounds over standard configurations.
00399         /// Note that the current version of Wwise only supports positioning on the plane.
00400         /// The speaker angles are expressed as an array of loudspeaker pairs, in degrees, relative to azimuth ]0,180].
00401         /// Supported loudspeaker setups are always symmetric; the center speaker is always in the middle and thus not specified by angles.
00402         /// Angles must be set in ascending order. 
00403         /// Typical usage: 
00404         /// - Initialize the sound engine and/or add secondary output(s).
00405         /// - Get number of speaker angles and their value into an array using GetSpeakerAngles().
00406         /// - Modify the angles and call SetSpeakerAngles().
00407         /// This function posts a message to the audio thread through the command queue, so it is thread safe. However the result may not be immediately read with GetSpeakerAngles().
00408         /// \warning This function only applies to configurations (or subset of these configurations) that are standard and whose speakers are on the plane (2D).
00409         /// \return AK_Success if successful.
00410         /// \sa GetSpeakerAngles()
00411         AK_EXTERNAPIFUNC( AKRESULT, SetSpeakerAngles )(
00412             AkReal32 *          in_pfSpeakerAngles,         ///< Array of loudspeaker pair angles, in degrees relative to azimuth [0,180].
00413             AkUInt32            in_uNumAngles,              ///< Number of elements in in_pfSpeakerAngles. It must correspond to AK::GetNumberOfAnglesForConfig( AK_SPEAKER_SETUP_DEFAULT_PLANE ) (the value returned by GetSpeakerAngles()).
00414             AkReal32            in_fHeightAngle,            ///< Elevation of the height layer, in degrees relative to the plane  [-90,90].
00415             AkOutputDeviceID    in_idOutput = 0             ///< Output ID to set the bus on.  As returned from AddOutput or GetOutputID.  You can pass 0 for the main (default) output         
00416             );
00417 
00418         /// Allows the game to set the volume threshold to be used by the sound engine to determine if a voice must go virtual.
00419         /// This may be changed anytime once the sound engine was initialized.
00420         /// If this function is not called, the used value will be the value specified in the platform specific project settings.
00421         /// \return 
00422         /// - AK_InvalidParameter if the threshold was not between 0 and -96.3 dB.
00423         /// - AK_Success if successful
00424         AK_EXTERNAPIFUNC( AKRESULT, SetVolumeThreshold )( 
00425             AkReal32 in_fVolumeThresholdDB ///< Volume Threshold, must be a value between 0 and -96.3 dB
00426             );
00427 
00428         /// Allows the game to set the maximum number of non virtual voices to be played simultaneously.
00429         /// This may be changed anytime once the sound engine was initialized.
00430         /// If this function is not called, the used value will be the value specified in the platform specific project settings.
00431         /// \return 
00432         /// - AK_InvalidParameter if the threshold was not between 1 and MaxUInt16.
00433         /// - AK_Success if successful
00434         AK_EXTERNAPIFUNC( AKRESULT, SetMaxNumVoicesLimit )( 
00435             AkUInt16 in_maxNumberVoices ///< Maximum number of non-virtual voices.
00436             );
00437                 
00438         //@}
00439 
00440         ////////////////////////////////////////////////////////////////////////
00441         /// @name Rendering Audio
00442         //@{
00443 
00444         /// Processes all commands in the sound engine's command queue.
00445         /// This method has to be called periodically (usually once per game frame).
00446         /// \sa 
00447         /// - \ref concept_events
00448         /// - \ref soundengine_events
00449         /// - <tt>AK::SoundEngine::PostEvent()</tt>
00450         /// \return Always returns AK_Success
00451         AK_EXTERNAPIFUNC( AKRESULT, RenderAudio )( 
00452             bool in_bAllowSyncRender = true             ///< When AkInitSettings::bUseLEngineThread is false, RenderAudio may generate an audio buffer -- unless in_bAllowSyncRender is set to false. Use in_bAllowSyncRender=false when calling RenderAudio from a Sound Engine callback.
00453             );
00454 
00455         //@}
00456 
00457         ////////////////////////////////////////////////////////////////////////
00458         /// @name Component Registration
00459         //@{
00460 
00461         /// Query interface to global plug-in context used for plug-in registration/initialization.
00462         /// \return Global plug-in context.
00463         AK_EXTERNAPIFUNC(AK::IAkGlobalPluginContext *, GetGlobalPluginContext)();
00464 
00465         /// Registers a plug-in with the sound engine and sets the callback functions to create the 
00466         /// plug-in and its parameter node.  
00467         /// \aknote 
00468         /// This function is deprecated. Registration is now automatic if you link plug-ins statically. If plug-ins are dynamic libraries (such as DLLs or SOs), use \c RegisterPluginDLL.
00469         /// \endaknote
00470         /// \sa
00471         /// - \ref register_effects
00472         /// - \ref plugin_xml
00473         /// \return AK_Success if successful, AK_InvalidParameter if invalid parameters were provided or Ak_Fail otherwise. Possible reasons for an AK_Fail result are:
00474         /// - Insufficient memory to register the plug-in
00475         /// - Plug-in ID already registered
00476         /// \remarks
00477         /// Codecs and plug-ins must be registered before loading banks that use them.\n
00478         /// Loading a bank referencing an unregistered plug-in or codec will result in a load bank success,
00479         /// but the plug-ins will not be used. More specifically, playing a sound that uses an unregistered effect plug-in 
00480         /// will result in audio playback without applying the said effect. If an unregistered source plug-in is used by an event's audio objects, 
00481         /// posting the event will fail.
00482         AK_EXTERNAPIFUNC( AKRESULT, RegisterPlugin )( 
00483             AkPluginType in_eType,                      ///< Plug-in type (for example, source or effect)
00484             AkUInt32 in_ulCompanyID,                    ///< Company identifier (as declared in the plug-in description XML file)
00485             AkUInt32 in_ulPluginID,                     ///< Plug-in identifier (as declared in the plug-in description XML file)
00486             AkCreatePluginCallback in_pCreateFunc,      ///< Pointer to the plug-in's creation function
00487             AkCreateParamCallback in_pCreateParamFunc   ///< Pointer to the plug-in's parameter node creation function
00488             );
00489 
00490         /// Loads a plug-in dynamic library and registers it with the sound engine.  
00491         /// With dynamic linking, all plugins are automatically registered.
00492         /// The plug-in DLL must be in the OS-specific library path or in the same location as the executable. If not, set AkInitSettings.szPluginDLLPath.
00493         /// \return 
00494         /// - Ak_Success if successful.  
00495         /// - AK_FileNotFound if the DLL is not found in the OS path or if it has extraneous dependencies not found.  
00496         /// - AK_InvalidFile if the symbol g_pAKPluginList is not exported by the dynamic library
00497         AK_EXTERNAPIFUNC( AKRESULT, RegisterPluginDLL ) (
00498             const AkOSChar* in_DllName                  ///< Name of the DLL to load, without "lib" prefix or extension.  
00499             );
00500         
00501         /// Registers a codec type with the sound engine and set the callback functions to create the 
00502         /// codec's file source and bank source nodes.
00503         /// \aknote 
00504         /// This function is deprecated. Registration is now automatic if you link plugins statically. If plugins are dynamic libraries (such as DLLs or SOs), use RegisterPluginDLL.
00505         /// \endaknote      
00506         /// \sa 
00507         /// - \ref register_effects
00508         /// \return AK_Success if successful, AK_InvalidParameter if invalid parameters were provided, or Ak_Fail otherwise. Possible reasons for an AK_Fail result are:
00509         /// - Insufficient memory to register the codec
00510         /// - Codec ID already registered
00511         /// \remarks
00512         /// Codecs and plug-ins must be registered before loading banks that use them.\n
00513         /// Loading a bank referencing an unregistered plug-in or codec will result in a load bank success,
00514         /// but the plug-ins will not be used. More specifically, playing a sound that uses an unregistered effect plug-in 
00515         /// will result in audio playback without applying the said effect. If an unregistered source plug-in is used by an event's audio objects, 
00516         /// posting the Event will fail.
00517         AK_EXTERNAPIFUNC( AKRESULT, RegisterCodec )( 
00518             AkUInt32 in_ulCompanyID,                        ///< Company identifier (as declared in the plug-in description XML file)
00519             AkUInt32 in_ulCodecID,                          ///< Codec identifier (as declared in the plug-in description XML file)
00520             AkCreateFileSourceCallback in_pFileCreateFunc,  ///< Pointer to the codec's file source node creation function
00521             AkCreateBankSourceCallback in_pBankCreateFunc   ///< Pointer to the codec's bank source node creation function
00522             );
00523 
00524         /// Registers a global callback function. This function will be called from the audio rendering thread, at the
00525         /// location specified by in_eLocation. This function will also be called from the thread calling           
00526         /// AK::SoundEngine::Term with in_eLocation set to AkGlobalCallbackLocation_Term.
00527         /// For example, in order to be called at every audio rendering pass, and once during teardown for releasing resources, you would call 
00528         /// RegisterGlobalCallback(myCallback, AkGlobalCallbackLocation_BeginRender  | AkGlobalCallbackLocation_Term, myCookie, AkPluginTypeNone, 0, 0);  
00529         /// \remarks
00530         /// A Plugin Type, Company ID and Plugin ID can be provided to this function to enable timing in the performance montior.
00531         /// If the callback is being timed, it will contribute to the Total Plug-in CPU measurement, and also appear in the Plug-ins tab of the Advanced Profiler by plug-in type and ID. 
00532         /// It is illegal to call this function while already inside of a global callback.
00533         /// This function might stall for several milliseconds before returning.
00534         /// \sa 
00535         /// - <tt>AK::SoundEngine::UnregisterGlobalCallback()</tt>
00536         /// - AkGlobalCallbackFunc
00537         /// - AkGlobalCallbackLocation
00538         AK_EXTERNAPIFUNC(AKRESULT, RegisterGlobalCallback)(
00539             AkGlobalCallbackFunc in_pCallback,              ///< Function to register as a global callback.
00540             AkUInt32 in_eLocation = AkGlobalCallbackLocation_BeginRender, ///< Callback location defined in AkGlobalCallbackLocation. Bitwise OR multiple locations if needed.
00541             void * in_pCookie = NULL,                       ///< User cookie.
00542             AkPluginType in_eType = AkPluginTypeNone,       ///< Plug-in type (for example, source or effect). AkPluginTypeNone for no timing.
00543             AkUInt32 in_ulCompanyID = 0,                    ///< Company identifier (as declared in the plug-in description XML file). 0 for no timing. 
00544             AkUInt32 in_ulPluginID = 0                      ///< Plug-in identifier (as declared in the plug-in description XML file). 0 for no timing. 
00545             );
00546 
00547         /// Unregisters a global callback function, previously registered using RegisterGlobalCallback.
00548         /// \remarks
00549         /// It is legal to call this function while already inside of a global callback, If it is unregistering itself and not
00550         /// another callback.
00551         /// This function might stall for several milliseconds before returning.
00552         /// \sa 
00553         /// - <tt>AK::SoundEngine::RegisterGlobalCallback()</tt>
00554         /// - AkGlobalCallbackFunc
00555         /// - AkGlobalCallbackLocation
00556         AK_EXTERNAPIFUNC(AKRESULT, UnregisterGlobalCallback)(
00557             AkGlobalCallbackFunc in_pCallback,              ///< Function to unregister as a global callback.
00558             AkUInt32 in_eLocation = AkGlobalCallbackLocation_BeginRender ///< Must match in_eLocation as passed to RegisterGlobalCallback for this callback.
00559             );
00560 
00561         /// Registers a callback for the Audio Device status changes.  
00562         /// The callback will be called from the audio thread
00563         /// Can be called prior to AK::SoundEngine::Init
00564         AK_EXTERNAPIFUNC(AKRESULT, RegisterAudioDeviceStatusCallback)(
00565             AK::AkDeviceStatusCallbackFunc in_pCallback             ///< Function to register as a status callback.                     
00566             );
00567 
00568         /// Unregisters the callback for the Audio Device status changes, registered by RegisterAudioDeviceStatusCallback               
00569         AK_EXTERNAPIFUNC(AKRESULT, UnregisterAudioDeviceStatusCallback)();
00570         //@}
00571 
00572 #ifdef AK_SUPPORT_WCHAR
00573         ////////////////////////////////////////////////////////////////////////
00574         /// @name Getting ID from strings
00575         //@{
00576 
00577         /// Universal converter from Unicode string to ID for the sound engine.
00578         /// This function will hash the name based on a algorithm ( provided at : /AK/Tools/Common/AkFNVHash.h )
00579         /// Note:
00580         ///     This function does return a AkUInt32, which is totally compatible with:
00581         ///     AkUniqueID, AkStateGroupID, AkStateID, AkSwitchGroupID, AkSwitchStateID, AkRtpcID, and so on...
00582         /// \sa
00583         /// - <tt>AK::SoundEngine::PostEvent</tt>
00584         /// - <tt>AK::SoundEngine::SetRTPCValue</tt>
00585         /// - <tt>AK::SoundEngine::SetSwitch</tt>
00586         /// - <tt>AK::SoundEngine::SetState</tt>
00587         /// - <tt>AK::SoundEngine::PostTrigger</tt>
00588         /// - <tt>AK::SoundEngine::SetGameObjectAuxSendValues</tt>
00589         /// - <tt>AK::SoundEngine::LoadBank</tt>
00590         /// - <tt>AK::SoundEngine::UnloadBank</tt>
00591         /// - <tt>AK::SoundEngine::PrepareEvent</tt>
00592         /// - <tt>AK::SoundEngine::PrepareGameSyncs</tt>
00593         AK_EXTERNAPIFUNC( AkUInt32, GetIDFromString )( const wchar_t* in_pszString );
00594 #endif //AK_SUPPORT_WCHAR
00595 
00596         /// Universal converter from string to ID for the sound engine.
00597         /// This function will hash the name based on a algorithm ( provided at : /AK/Tools/Common/AkFNVHash.h )
00598         /// Note:
00599         ///     This function does return a AkUInt32, which is totally compatible with:
00600         ///     AkUniqueID, AkStateGroupID, AkStateID, AkSwitchGroupID, AkSwitchStateID, AkRtpcID, and so on...
00601         /// \sa
00602         /// - <tt>AK::SoundEngine::PostEvent</tt>
00603         /// - <tt>AK::SoundEngine::SetRTPCValue</tt>
00604         /// - <tt>AK::SoundEngine::SetSwitch</tt>
00605         /// - <tt>AK::SoundEngine::SetState</tt>
00606         /// - <tt>AK::SoundEngine::PostTrigger</tt>
00607         /// - <tt>AK::SoundEngine::SetGameObjectAuxSendValues</tt>
00608         /// - <tt>AK::SoundEngine::LoadBank</tt>
00609         /// - <tt>AK::SoundEngine::UnloadBank</tt>
00610         /// - <tt>AK::SoundEngine::PrepareEvent</tt>
00611         /// - <tt>AK::SoundEngine::PrepareGameSyncs</tt>
00612         AK_EXTERNAPIFUNC( AkUInt32, GetIDFromString )( const char* in_pszString );
00613 
00614         //@}
00615 
00616         ////////////////////////////////////////////////////////////////////////
00617         /// @name Event Management
00618         //@{
00619 
00620         /// Asynchronously posts an Event to the sound engine (by event ID).
00621         /// The callback function can be used to be noticed when markers are reached or when the event is finished.
00622         /// An array of wave file sources can be provided to resolve External Sources triggered by the event. 
00623         /// \return The playing ID of the event launched, or AK_INVALID_PLAYING_ID if posting the event failed
00624         /// \remarks
00625         /// If used, the array of external sources should contain the information for each external source triggered by the
00626         /// event. When triggering an event with multiple external sources, you need to differentiate each source 
00627         /// by using the cookie property in the External Source in the Wwise project and in AkExternalSourceInfo.
00628         /// \aknote If an event triggers the playback of more than one external source, they must be named uniquely in the project 
00629         /// (therefore have a unique cookie) in order to tell them apart when filling the AkExternalSourceInfo structures.
00630         /// \endaknote
00631         /// \sa 
00632         /// - \ref concept_events
00633         /// - \ref integrating_external_sources
00634         /// - <tt>AK::SoundEngine::RenderAudio()</tt>
00635         /// - <tt>AK::SoundEngine::GetIDFromString()</tt>
00636         /// - <tt>AK::SoundEngine::GetSourcePlayPosition()</tt>
00637         AK_EXTERNAPIFUNC( AkPlayingID, PostEvent )(
00638             AkUniqueID in_eventID,                          ///< Unique ID of the event
00639             AkGameObjectID in_gameObjectID,                 ///< Associated game object ID
00640             AkUInt32 in_uFlags = 0,                         ///< Bitmask: see \ref AkCallbackType
00641             AkCallbackFunc in_pfnCallback = NULL,           ///< Callback function
00642             void * in_pCookie = NULL,                       ///< Callback cookie that will be sent to the callback function along with additional information
00643             AkUInt32 in_cExternals = 0,                     ///< Optional count of external source structures
00644             AkExternalSourceInfo *in_pExternalSources = NULL,///< Optional array of external source resolution information
00645             AkPlayingID in_PlayingID = AK_INVALID_PLAYING_ID///< Optional (advanced users only) Specify the playing ID to target with the event. Will Cause active actions in this event to target an existing Playing ID. Let it be AK_INVALID_PLAYING_ID or do not specify any for normal playback.
00646             );
00647 
00648 #ifdef AK_SUPPORT_WCHAR
00649         /// Posts an Event to the sound engine (by Event name), using callbacks.
00650         /// The callback function can be used to be noticed when markers are reached or when the event is finished.
00651         /// An array of wave file sources can be provided to resolve External Sources triggered by the event. 
00652         /// \return The playing ID of the event launched, or AK_INVALID_PLAYING_ID if posting the event failed
00653         /// \remarks
00654         /// If used, the array of external sources should contain the information for each external source triggered by the
00655         /// event. When triggering an event with multiple external sources, you need to differentiate each source 
00656         /// by using the cookie property in the External Source in the Wwise project and in AkExternalSourceInfo.
00657         /// \aknote If an event triggers the playback of more than one external source, they must be named uniquely in the project 
00658         /// (therefore have a unique cookie) in order to tell them appart when filling the AkExternalSourceInfo structures.
00659         /// \endaknote
00660         /// \sa 
00661         /// - \ref concept_events
00662         /// - \ref integrating_external_sources
00663         /// - <tt>AK::SoundEngine::RenderAudio()</tt>
00664         /// - <tt>AK::SoundEngine::GetIDFromString()</tt>
00665         /// - <tt>AK::SoundEngine::GetSourcePlayPosition()</tt>
00666         AK_EXTERNAPIFUNC( AkPlayingID, PostEvent )(
00667             const wchar_t* in_pszEventName,                 ///< Name of the event
00668             AkGameObjectID in_gameObjectID,                 ///< Associated game object ID
00669             AkUInt32 in_uFlags = 0,                         ///< Bitmask: see \ref AkCallbackType
00670             AkCallbackFunc in_pfnCallback = NULL,           ///< Callback function
00671             void * in_pCookie = NULL,                       ///< Callback cookie that will be sent to the callback function along with additional information.
00672             AkUInt32 in_cExternals = 0,                     ///< Optional count of external source structures
00673             AkExternalSourceInfo *in_pExternalSources = NULL,///< Optional array of external source resolution information
00674             AkPlayingID in_PlayingID = AK_INVALID_PLAYING_ID///< Optional (advanced users only) Specify the playing ID to target with the event. Will Cause active actions in this event to target an existing Playing ID. Let it be AK_INVALID_PLAYING_ID or do not specify any for normal playback.
00675             );
00676 #endif //AK_SUPPORT_WCHAR
00677 
00678         /// Posts an Event to the sound engine (by Event name), using callbacks.
00679         /// The callback function can be used to be noticed when markers are reached or when the event is finished.
00680         /// An array of Wave file sources can be provided to resolve External Sources triggered by the event. P
00681         /// \return The playing ID of the event launched, or AK_INVALID_PLAYING_ID if posting the event failed
00682         /// \remarks
00683         /// If used, the array of external sources should contain the information for each external source triggered by the
00684         /// event. When triggering an Event with multiple external sources, you need to differentiate each source 
00685         /// by using the cookie property in the External Source in the Wwise project and in AkExternalSourceInfo.
00686         /// \aknote If an event triggers the playback of more than one external source, they must be named uniquely in the project 
00687         /// (therefore have a unique cookie) in order to tell them apart when filling the AkExternalSourceInfo structures.
00688         /// \endaknote
00689         /// \sa 
00690         /// - \ref concept_events
00691         /// - \ref integrating_external_sources
00692         /// - <tt>AK::SoundEngine::RenderAudio()</tt>
00693         /// - <tt>AK::SoundEngine::GetIDFromString()</tt>
00694         /// - <tt>AK::SoundEngine::GetSourcePlayPosition()</tt>
00695         AK_EXTERNAPIFUNC( AkPlayingID, PostEvent )(
00696             const char* in_pszEventName,                    ///< Name of the event
00697             AkGameObjectID in_gameObjectID,                 ///< Associated game object ID
00698             AkUInt32 in_uFlags = 0,                         ///< Bitmask: see \ref AkCallbackType
00699             AkCallbackFunc in_pfnCallback = NULL,           ///< Callback function
00700             void * in_pCookie = NULL,                       ///< Callback cookie that will be sent to the callback function along with additional information.
00701             AkUInt32 in_cExternals = 0,                     ///< Optional count of external source structures
00702             AkExternalSourceInfo *in_pExternalSources = NULL,///< Optional array of external source resolution information
00703             AkPlayingID in_PlayingID = AK_INVALID_PLAYING_ID///< Optional (advanced users only) Specify the playing ID to target with the event. Will Cause active actions in this event to target an existing Playing ID. Let it be AK_INVALID_PLAYING_ID or do not specify any for normal playback.
00704             );
00705 
00706         // If you modify AkActionOnEventType, don't forget to modify the WAAPI validation schema accordingly.
00707 
00708         /// AkActionOnEventType
00709         /// \sa
00710         /// - <tt>AK::SoundEngine::ExecuteActionOnEvent()</tt>
00711         enum AkActionOnEventType
00712         {
00713             AkActionOnEventType_Stop    = 0,            ///< Stop
00714             AkActionOnEventType_Pause   = 1,            ///< Pause
00715             AkActionOnEventType_Resume  = 2,            ///< Resume
00716             AkActionOnEventType_Break   = 3,            ///< Break
00717             AkActionOnEventType_ReleaseEnvelope = 4     ///< Release envelope
00718         };
00719 
00720         /// Executes an action on all nodes that are referenced in the specified event in an action of type play.
00721         /// \sa
00722         /// - <tt>AK::SoundEngine::AkActionOnEventType</tt>
00723         AK_EXTERNAPIFUNC( AKRESULT, ExecuteActionOnEvent )(
00724             AkUniqueID in_eventID,                                              ///< Unique ID of the event
00725             AkActionOnEventType in_ActionType,                                  ///< Action to execute on all the elements that were played using the specified event.
00726             AkGameObjectID in_gameObjectID = AK_INVALID_GAME_OBJECT,            ///< Associated game object ID
00727             AkTimeMs in_uTransitionDuration = 0,                                ///< Fade duration
00728             AkCurveInterpolation in_eFadeCurve = AkCurveInterpolation_Linear,   ///< Curve type to be used for the transition
00729             AkPlayingID in_PlayingID = AK_INVALID_PLAYING_ID                    ///< Associated PlayingID
00730             );
00731 
00732 #ifdef AK_SUPPORT_WCHAR
00733         /// Executes an action on all nodes that are referenced in the specified event in an action of type play.
00734         /// \sa
00735         /// - <tt>AK::SoundEngine::AkActionOnEventType</tt>
00736         AK_EXTERNAPIFUNC( AKRESULT, ExecuteActionOnEvent )(
00737             const wchar_t* in_pszEventName,                                     ///< Name of the event
00738             AkActionOnEventType in_ActionType,                                  ///< Action to execute on all the elements that were played using the specified event.
00739             AkGameObjectID in_gameObjectID = AK_INVALID_GAME_OBJECT,            ///< Associated game object ID
00740             AkTimeMs in_uTransitionDuration = 0,                                ///< Fade duration
00741             AkCurveInterpolation in_eFadeCurve = AkCurveInterpolation_Linear,   ///< Curve type to be used for the transition
00742             AkPlayingID in_PlayingID = AK_INVALID_PLAYING_ID                    ///< Associated PlayingID
00743             );
00744 #endif //AK_SUPPORT_WCHAR
00745 
00746         /// Executes an Action on all nodes that are referenced in the specified Event in an Action of type Play.
00747         /// \sa
00748         /// - <tt>AK::SoundEngine::AkActionOnEventType</tt>
00749         AK_EXTERNAPIFUNC( AKRESULT, ExecuteActionOnEvent )(
00750             const char* in_pszEventName,                                        ///< Name of the event
00751             AkActionOnEventType in_ActionType,                                  ///< Action to execute on all the elements that were played using the specified event.
00752             AkGameObjectID in_gameObjectID = AK_INVALID_GAME_OBJECT,            ///< Associated game object ID
00753             AkTimeMs in_uTransitionDuration = 0,                                ///< Fade duration
00754             AkCurveInterpolation in_eFadeCurve = AkCurveInterpolation_Linear,   ///< Curve type to be used for the transition
00755             AkPlayingID in_PlayingID = AK_INVALID_PLAYING_ID                    ///< Associated PlayingID
00756             );
00757 
00758 
00759         /// Executes a number of MIDI Events on all nodes that are referenced in the specified Event in an Action of type Play.
00760         /// Each MIDI event will be posted in AkMIDIPost::uOffset samples from the start of the current frame. The duration of
00761         /// a sample can be determined from the sound engine's audio settings, via a call to AK::SoundEngine::GetAudioSettings.
00762         /// \sa
00763         /// - <tt>AK::SoundEngine::GetAudioSettings</tt>
00764         /// - <tt>AK::SoundEngine::StopMIDIOnEvent</tt>
00765         AK_EXTERNAPIFUNC( AKRESULT, PostMIDIOnEvent )(
00766             AkUniqueID in_eventID,                                          ///< Unique ID of the Event
00767             AkGameObjectID in_gameObjectID,                                 ///< Associated game object ID
00768             AkMIDIPost* in_pPosts,                                          ///< MIDI Events to post
00769             AkUInt16 in_uNumPosts                                           ///< Number of MIDI Events to post
00770             );
00771 
00772         /// Stops MIDI notes on all nodes that are referenced in the specified event in an action of type play,
00773         /// with the specified Game Object. Invalid parameters are interpreted as wildcards. For example, calling
00774         /// this function with in_eventID set to AK_INVALID_UNIQUE_ID will stop all MIDI notes for Game Object
00775         /// in_gameObjectID.
00776         /// \sa
00777         /// - <tt>AK::SoundEngine::PostMIDIOnEvent</tt>
00778         AK_EXTERNAPIFUNC( AKRESULT, StopMIDIOnEvent )(
00779             AkUniqueID in_eventID = AK_INVALID_UNIQUE_ID,                   ///< Unique ID of the Event
00780             AkGameObjectID in_gameObjectID = AK_INVALID_GAME_OBJECT         ///< Associated game object ID
00781             );
00782 
00783 
00784         /// Starts streaming the first part of all streamed files referenced by an Event into a cache buffer. Caching streams are serviced when no other streams require the 
00785         /// available bandwidth. The files will remain cached until UnpinEventInStreamCache is called, or a higher priority pinned file needs the space and the limit set by 
00786         /// uMaxCachePinnedBytes is exceeded.  
00787         /// \remarks The amount of data from the start of the file that will be pinned to cache is determined by the prefetch size. The prefetch size is set via the authoring tool and stored in the sound banks.  
00788         /// \remarks It is possible to override the prefetch size stored in the sound bank via the low level IO. For more information see <tt>AK::StreamMgr::IAkFileLocationResolver::Open()</tt> and AkFileSystemFlags.
00789         /// \remarks If this function is called additional times with the same event, then the priority of the caching streams are updated. Note however that priority is passed down to the stream manager 
00790         /// on a file-by-file basis, and if another event is pinned to cache that references the same file but with a different priority, then the first priority will be updated with the most recent value.
00791         /// \remarks If the event references files that are chosen based on a State Group (via a switch container), all files in all states will be cached. Those in the current active state
00792         /// will get cached with active priority, while all other files will get cached with inactive priority.
00793         /// \remarks in_uInactivePriority is only relevant for events that reference switch containers that are assigned to State Groups. This parameter is ignored for all other events, including events that only reference
00794         /// switch containers that are assigned to Switch Groups. Files that are chosen based on a Switch Group have a different switch value per game object, and are all effectively considered active by the pin-to-cache system.
00795         /// \sa
00796         /// - <tt>AK::SoundEngine::GetBufferStatusForPinnedEvent</tt>
00797         /// - <tt>AK::SoundEngine::UnpinEventInStreamCache</tt>
00798         /// - <tt>AK::StreamMgr::IAkFileLocationResolver::Open</tt>
00799         /// - AkFileSystemFlags
00800         AK_EXTERNAPIFUNC( AKRESULT, PinEventInStreamCache )(
00801             AkUniqueID in_eventID,                                          ///< Unique ID of the event
00802             AkPriority in_uActivePriority,                                  ///< Priority of active stream caching I/O
00803             AkPriority in_uInactivePriority                                 ///< Priority of inactive stream caching I/O
00804             );
00805 
00806 #ifdef AK_SUPPORT_WCHAR
00807         /// Starts streaming the first part of all streamed files referenced by an event into a cache buffer. Caching streams are serviced when no other streams require the 
00808         /// available bandwidth. The files will remain cached until UnpinEventInStreamCache is called, or a higher priority pinned file needs the space and the limit set by 
00809         /// uMaxCachePinnedBytes is exceeded.  
00810         /// \remarks The amount of data from the start of the file that will be pinned to cache is determined by the prefetch size. The prefetch size is set via the authoring tool and stored in the sound banks.  
00811         /// \remarks It is possible to override the prefetch size stored in the sound bank via the low level IO. For more information see <tt>AK::StreamMgr::IAkFileLocationResolver::Open()</tt> and AkFileSystemFlags.
00812         /// \remarks If this function is called additional times with the same event, then the priority of the caching streams are updated. Note however that priority is passed down to the stream manager 
00813         /// on a file-by-file basis, and if another event is pinned to cache that references the same file but with a different priority, then the first priority will be updated with the most recent value.
00814         /// \remarks If the event references files that are chosen based on a State Group (via a Switch Container), all files in all states will be cached. Those in the current active state
00815         /// will get cached with active priority, while all other files will get cached with inactive priority.
00816         /// \remarks in_uInactivePriority is only relevant for events that reference switch containers that are assigned to State Groups. This parameter is ignored for all other events, including events that only reference
00817         /// switch containers that are assigned to Switch Groups. Files that are chosen based on a Switch Group have a different switch value per game object, and are all effectively considered active by the pin-to-cache system.
00818         /// \sa
00819         /// - <tt>AK::SoundEngine::GetBufferStatusForPinnedEvent</tt>
00820         /// - <tt>AK::SoundEngine::UnpinEventInStreamCache</tt>
00821         /// - <tt>AK::StreamMgr::IAkFileLocationResolver::Open</tt>
00822         /// - AkFileSystemFlags
00823         AK_EXTERNAPIFUNC( AKRESULT, PinEventInStreamCache )(
00824             const wchar_t* in_pszEventName,                                 ///< Name of the event
00825             AkPriority in_uActivePriority,                                  ///< Priority of active stream caching I/O
00826             AkPriority in_uInactivePriority                                 ///< Priority of inactive stream caching I/O
00827             );
00828 #endif //AK_SUPPORT_WCHAR
00829 
00830         /// Starts streaming the first part of all streamed files referenced by an event into a cache buffer. Caching streams are serviced when no other streams require the 
00831         /// available bandwidth. The files will remain cached until UnpinEventInStreamCache is called, or a higher priority pinned file needs the space and the limit set by 
00832         /// uMaxCachePinnedBytes is exceeded.  
00833         /// \remarks The amount of data from the start of the file that will be pinned to cache is determined by the prefetch size. The prefetch size is set via the authoring tool and stored in the sound banks.  
00834         /// \remarks It is possible to override the prefetch size stored in the sound bank via the low level IO. For more information see <tt>AK::StreamMgr::IAkFileLocationResolver::Open()</tt> and AkFileSystemFlags.
00835         /// \remarks If this function is called additional times with the same event, then the priority of the caching streams are updated. Note however that priority is passed down to the stream manager 
00836         /// on a file-by-file basis, and if another event is pinned to cache that references the same file but with a different priority, then the first priority will be updated with the most recent value.
00837         /// \remarks If the event references files that are chosen based on a State Group (via a switch container), all files in all states will be cached. Those in the current active state
00838         /// will get cached with active priority, while all other files will get cached with inactive priority.
00839         /// \remarks in_uInactivePriority is only relevant for events that reference switch containers that are assigned to State Groups. This parameter is ignored for all other events, including events that only reference
00840         /// switch containers that are assigned to Switch Groups. Files that are chosen based on a Switch Group have a different switch value per game object, and are all effectively considered active by the pin-to-cache system.
00841         /// \sa
00842         /// - <tt>AK::SoundEngine::GetBufferStatusForPinnedEvent</tt>
00843         /// - <tt>AK::SoundEngine::UnpinEventInStreamCache</tt>
00844         /// - <tt>AK::StreamMgr::IAkFileLocationResolver::Open</tt>
00845         /// - AkFileSystemFlags
00846         AK_EXTERNAPIFUNC( AKRESULT, PinEventInStreamCache )(
00847             const char* in_pszEventName,                                    ///< Name of the event
00848             AkPriority in_uActivePriority,                                  ///< Priority of active stream caching I/O
00849             AkPriority in_uInactivePriority                                 ///< Priority of inactive stream caching I/O
00850             );
00851 
00852         /// Releases the set of files that were previously requested to be pinned into cache via <tt>AK::SoundEngine::PinEventInStreamCache()</tt>. The file may still remain in stream cache
00853         /// after <tt>AK::SoundEngine::UnpinEventInStreamCache()</tt> is called, until the memory is reused by the streaming memory manager in accordance with to its cache management algorithm.
00854         /// \sa
00855         /// - <tt>AK::SoundEngine::PinEventInStreamCache</tt>
00856         /// - <tt>AK::SoundEngine::GetBufferStatusForPinnedEvent</tt>
00857         AK_EXTERNAPIFUNC( AKRESULT, UnpinEventInStreamCache )(
00858             AkUniqueID in_eventID                                           ///< Unique ID of the event
00859             );  
00860 
00861 #ifdef AK_SUPPORT_WCHAR
00862         /// Releases the set of files that were previously requested to be pinned into cache via <tt>AK::SoundEngine::PinEventInStreamCache()</tt>. The file may still remain in stream cache
00863         /// after <tt>AK::SoundEngine::UnpinEventInStreamCache()</tt> is called, until the memory is reused by the streaming memory manager in accordance with to its cache management algorithm.
00864         /// \sa
00865         /// - <tt>AK::SoundEngine::PinEventInStreamCache</tt>
00866         /// - <tt>AK::SoundEngine::GetBufferStatusForPinnedEvent</tt>
00867         AK_EXTERNAPIFUNC( AKRESULT, UnpinEventInStreamCache )(
00868             const wchar_t* in_pszEventName                                  ///< Name of the event
00869             );
00870 #endif //AK_SUPPORT_WCHAR
00871 
00872         /// Releases the set of files that were previously requested to be pinned into cache via <tt>AK::SoundEngine::PinEventInStreamCache()</tt>. The file may still remain in stream cache
00873         /// after <tt>AK::SoundEngine::UnpinEventInStreamCache()</tt> is called, until the memory is reused by the streaming memory manager in accordance with to its cache management algorithm.
00874         /// \sa
00875         /// - <tt>AK::SoundEngine::PinEventInStreamCache</tt>
00876         /// - <tt>AK::SoundEngine::GetBufferStatusForPinnedEvent</tt>
00877         AK_EXTERNAPIFUNC( AKRESULT, UnpinEventInStreamCache )(
00878             const char* in_pszEventName                                     ///< Name of the event
00879             );
00880 
00881         /// Returns information about an Event that was requested to be pinned into cache via <tt>AK::SoundEngine::PinEventInStreamCache()</tt>.
00882         /// Retrieves the smallest buffer fill-percentage for each file referenced by the event, and whether 
00883         /// the cache-pinned memory limit is preventing any of the files from filling up their buffer.
00884         /// \remarks To set the limit for the maximum number of bytes that can be pinned to cache, see \c AkDeviceSettings 
00885         /// \sa
00886         /// - <tt>AK::SoundEngine::PinEventInStreamCache</tt>
00887         /// - <tt>AK::SoundEngine::UnpinEventInStreamCache</tt>
00888         /// - AkDeviceSettings
00889         AK_EXTERNAPIFUNC( AKRESULT, GetBufferStatusForPinnedEvent )(
00890             AkUniqueID in_eventID,                                          ///< Unique ID of the event
00891             AkReal32& out_fPercentBuffered,                                 ///< Fill-percentage (out of 100) of requested buffer size for least buffered file in the event.
00892             bool& out_bCachePinnedMemoryFull                                ///< True if at least one file can not complete buffering because the cache-pinned memory limit would be exceeded.
00893             );
00894 
00895         /// Returns information about an Event that was requested to be pinned into cache via \c <tt>AK::SoundEngine::PinEventInStreamCache()</tt>.
00896         /// Retrieves the smallest buffer fill-percentage for each file referenced by the event, and whether 
00897         /// the cache-pinned memory limit is preventing any of the files from filling up their buffer.
00898         /// \remarks To set the limit for the maximum number of bytes that can be pinned to cache, see AkDeviceSettings 
00899         /// \sa
00900         /// - <tt>AK::SoundEngine::PinEventInStreamCache</tt>
00901         /// - <tt>AK::SoundEngine::UnpinEventInStreamCache</tt>
00902         /// - AkDeviceSettings
00903         AK_EXTERNAPIFUNC( AKRESULT, GetBufferStatusForPinnedEvent )(
00904             const char* in_pszEventName,                                    ///< Name of the event
00905             AkReal32& out_fPercentBuffered,                                 ///< Fill-percentage (out of 100) of requested buffer size for least buffered file in the event.
00906             bool& out_bCachePinnedMemoryFull                                ///< True if at least one file can not complete buffering because the cache-pinned memory limit would be exceeded.
00907             );
00908 
00909 #ifdef AK_SUPPORT_WCHAR
00910         /// Returns information about an Event that was requested to be pinned into cache via \c <tt>AK::SoundEngine::PinEventInStreamCache()</tt>.
00911         /// Retrieves the smallest buffer fill-percentage for each file referenced by the event, and whether 
00912         /// the cache-pinned memory limit is preventing any of the files from filling up their buffer.
00913         /// \remarks To set the limit for the maximum number of bytes that can be pinned to cache, see AkDeviceSettings 
00914         /// \sa
00915         /// - <tt>AK::SoundEngine::PinEventInStreamCache</tt>
00916         /// - <tt>AK::SoundEngine::UnpinEventInStreamCache</tt>
00917         /// - AkDeviceSettings
00918         AK_EXTERNAPIFUNC( AKRESULT, GetBufferStatusForPinnedEvent )(
00919             const wchar_t* in_pszEventName,                                 ///< Name of the event
00920             AkReal32& out_fPercentBuffered,                                 ///< Fill-percentage (out of 100) of requested buffer size for least buffered file in the event.
00921             bool& out_bCachePinnedMemoryFull                                ///< True if at least one file can not complete buffering because the cache-pinned memory limit would be exceeded.
00922             );
00923 #endif
00924 
00925         /// Seeks inside all playing objects that are referenced in Play Actions of the specified Event.
00926         ///
00927         /// Notes:
00928         ///     - This works with all objects of the actor-mixer hierarchy, and also with Music Segments and Music Switch Containers. 
00929         ///     - There is a restriction with sounds that play within a continuous sequence. Seeking is ignored 
00930         ///         if one of their ancestors is a continuous (random or sequence) container with crossfade or 
00931         ///         trigger rate transitions. Seeking is also ignored with sample-accurate transitions, unless
00932         ///         the sound that is currently playing is the first sound of the sequence.
00933         ///     - Seeking is also ignored with voices that can go virtual with "From Beginning" behavior. 
00934         ///     - Sounds/segments are stopped if in_iPosition is greater than their duration.
00935         ///     - in_iPosition is clamped internally to the beginning of the sound/segment.
00936         ///     - If the option "Seek to nearest marker" is used, the seeking position snaps to the nearest marker.
00937         ///         With objects of the actor-mixer hierarchy, markers are embedded in wave files by an external wave editor.
00938         ///         Note that looping regions ("sampler loop") are not considered as markers. Also, the "add file name marker" of the 
00939         ///         conversion settings dialog adds a marker at the beginning of the file, which is considered when seeking
00940         ///         to nearest marker. In the case of objects of the interactive music hierarchy, user (wave) markers are ignored:
00941         ///         seeking occurs to the nearest segment cue (authored in the segment editor), including the Entry Cue, but excluding the Exit Cue.
00942         ///     - This method posts a command in the sound engine queue, thus seeking will not occur before 
00943         ///         the audio thread consumes it (after a call to RenderAudio()). 
00944         ///
00945         /// Notes specific to Music Segments:
00946         ///     - With Music Segments, in_iPosition is relative to the Entry Cue, in milliseconds. Use a negative
00947         ///         value to seek within the Pre-Entry.
00948         ///     - Music segments cannot be looped. You may want to listen to the AK_EndOfEvent notification 
00949         ///         in order to restart them if required.
00950         ///     - In order to restart at the correct location, with all their tracks synchronized, Music Segments 
00951         ///         take the "look-ahead time" property of their streamed tracks into account for seeking. 
00952         ///         Consequently, the resulting position after a call to SeekOnEvent() might be earlier than the 
00953         ///         value that was passed to the method. Use <tt>AK::MusicEngine::GetPlayingSegmentInfo()</tt> to query 
00954         ///         the exact position of a segment. Also, the segment will be silent during that time
00955         ///         (so that it restarts precisely at the position that you specified). <tt>AK::MusicEngine::GetPlayingSegmentInfo()</tt> 
00956         ///         also informs you about the remaining look-ahead time.  
00957         ///
00958         /// Notes specific to Music Switch Containers:
00959         ///     - Seeking triggers a music transition towards the current (or target) segment.
00960         ///         This transition is subject to the container's transition rule that matches the current and defined in the container,
00961         ///         so the moment when seeking occurs depends on the rule's "Exit At" property. On the other hand, the starting position 
00962         ///         in the target segment depends on both the desired seeking position and the rule's "Sync To" property.
00963         ///     - If the specified time is greater than the destination segment's length, the modulo is taken.
00964         ///
00965         /// \sa
00966         /// - <tt>AK::SoundEngine::RenderAudio()</tt>
00967         /// - <tt>AK::SoundEngine::PostEvent()</tt>
00968         /// - <tt>AK::SoundEngine::GetSourcePlayPosition()</tt>
00969         /// - <tt>AK::MusicEngine::GetPlayingSegmentInfo()</tt>
00970         AK_EXTERNAPIFUNC( AKRESULT, SeekOnEvent )( 
00971             AkUniqueID in_eventID,                                      ///< Unique ID of the event
00972             AkGameObjectID in_gameObjectID,                             ///< Associated game object ID; use AK_INVALID_GAME_OBJECT to affect all game objects
00973             AkTimeMs in_iPosition,                                      ///< Desired position where playback should restart, in milliseconds
00974             bool in_bSeekToNearestMarker = false,                       ///< If true, the final seeking position will be made equal to the nearest marker (see note above)
00975             AkPlayingID in_PlayingID = AK_INVALID_PLAYING_ID            ///< Specify the playing ID for the seek to be applied to. Will result in the seek happening only on active actions of the playing ID. Let it be AK_INVALID_PLAYING_ID or do not specify any, to seek on all active actions of this event ID.
00976             );
00977 
00978 #ifdef AK_SUPPORT_WCHAR
00979         /// Seeks inside all playing objects that are referenced in Play Actions of the specified Event.
00980         ///
00981         /// Notes:
00982         ///     - This works with all objects of the actor-mixer hierarchy, and also with Music Segments and Music Switch Containers. 
00983         ///     - There is a restriction with sounds that play within a continuous sequence. Seeking is ignored 
00984         ///         if one of their ancestors is a continuous (random or sequence) container with crossfade or 
00985         ///         trigger rate transitions. Seeking is also ignored with sample-accurate transitions, unless
00986         ///         the sound that is currently playing is the first sound of the sequence.
00987         ///     - Seeking is also ignored with voices that can go virtual with "From Beginning" behavior. 
00988         ///     - With Music Segments, in_iPosition is relative to the Entry Cue, in milliseconds. Use a negative
00989         ///         value to seek within the Pre-Entry.
00990         ///     - Sounds/segments are stopped if in_iPosition is greater than their duration.
00991         ///     - in_iPosition is clamped internally to the beginning of the sound/segment.
00992         ///     - If the option "Seek to nearest marker" is used, the seeking position snaps to the nearest marker.
00993         ///         With objects of the actor-mixer hierarchy, markers are embedded in wave files by an external wave editor.
00994         ///         Note that looping regions ("sampler loop") are not considered as markers. Also, the "add file name marker" of the 
00995         ///         conversion settings dialog adds a marker at the beginning of the file, which is considered when seeking
00996         ///         to nearest marker. In the case of objects of the interactive music hierarchy, user (wave) markers are ignored:
00997         ///         seeking occurs to the nearest segment cue (authored in the segment editor), including the Entry Cue, but excluding the Exit Cue.
00998         ///     - This method posts a command in the sound engine queue, thus seeking will not occur before 
00999         ///         the audio thread consumes it (after a call to RenderAudio()). 
01000         ///
01001         /// Notes specific to Music Segments:
01002         ///     - With Music Segments, in_iPosition is relative to the Entry Cue, in milliseconds. Use a negative
01003         ///         value to seek within the Pre-Entry.
01004         ///     - Music segments cannot be looped. You may want to listen to the AK_EndOfEvent notification 
01005         ///         in order to restart them if required.
01006         ///     - In order to restart at the correct location, with all their tracks synchronized, Music Segments 
01007         ///         take the "look-ahead time" property of their streamed tracks into account for seeking. 
01008         ///         Consequently, the resulting position after a call to SeekOnEvent() might be earlier than the 
01009         ///         value that was passed to the method. Use <tt>AK::MusicEngine::GetPlayingSegmentInfo()</tt> to query 
01010         ///         the exact position of a segment. Also, the segment will be silent during that time
01011         ///         (so that it restarts precisely at the position that you specified). <tt>AK::MusicEngine::GetPlayingSegmentInfo()</tt> 
01012         ///         also informs you about the remaining look-ahead time. 
01013         ///
01014         /// Notes specific to Music Switch Containers:
01015         ///     - Seeking triggers a music transition towards the current (or target) segment.
01016         ///         This transition is subject to the container's transition rule that matches the current and defined in the container,
01017         ///         so the moment when seeking occurs depends on the rule's "Exit At" property. On the other hand, the starting position 
01018         ///         in the target segment depends on both the desired seeking position and the rule's "Sync To" property.
01019         ///     - If the specified time is greater than the destination segment's length, the modulo is taken.
01020         ///
01021         /// \sa
01022         /// - <tt>AK::SoundEngine::RenderAudio()</tt>
01023         /// - <tt>AK::SoundEngine::PostEvent()</tt>
01024         /// - <tt>AK::SoundEngine::GetSourcePlayPosition()</tt>
01025         /// - <tt>AK::MusicEngine::GetPlayingSegmentInfo()</tt>
01026         AK_EXTERNAPIFUNC( AKRESULT, SeekOnEvent )( 
01027             const wchar_t* in_pszEventName,                             ///< Name of the event
01028             AkGameObjectID in_gameObjectID,                             ///< Associated game object ID; use AK_INVALID_GAME_OBJECT to affect all game objects
01029             AkTimeMs in_iPosition,                                      ///< Desired position where playback should restart, in milliseconds
01030             bool in_bSeekToNearestMarker = false,                       ///< If true, the final seeking position will be made equal to the nearest marker (see note above)
01031             AkPlayingID in_PlayingID = AK_INVALID_PLAYING_ID            ///< Specify the playing ID for the seek to be applied to. Will result in the seek happening only on active actions of the playing ID. Let it be AK_INVALID_PLAYING_ID or do not specify any, to seek on all active actions of this event ID.   
01032             );
01033 #endif //AK_SUPPORT_WCHAR
01034 
01035         /// Seeks inside all playing objects that are referenced in Play Actions of the specified Event.
01036         ///
01037         /// Notes:
01038         ///     - This works with all objects of the actor-mixer hierarchy, and also with Music Segments and Music Switch Containers. 
01039         ///     - There is a restriction with sounds that play within a continuous sequence. Seeking is ignored 
01040         ///         if one of their ancestors is a continuous (random or sequence) container with crossfade or 
01041         ///         trigger rate transitions. Seeking is also ignored with sample-accurate transitions, unless
01042         ///         the sound that is currently playing is the first sound of the sequence.
01043         ///     - Seeking is also ignored with voices that can go virtual with "From Beginning" behavior. 
01044         ///     - With Music Segments, in_iPosition is relative to the Entry Cue, in milliseconds. Use a negative
01045         ///         value to seek within the Pre-Entry.
01046         ///     - Sounds/segments are stopped if in_iPosition is greater than their duration.
01047         ///     - in_iPosition is clamped internally to the beginning of the sound/segment.
01048         ///     - If the option "Seek to nearest marker" is used, the seeking position snaps to the nearest marker.
01049         ///         With objects of the actor-mixer hierarchy, markers are embedded in wave files by an external wave editor.
01050         ///         Note that looping regions ("sampler loop") are not considered as markers. Also, the "add file name marker" of the 
01051         ///         conversion settings dialog adds a marker at the beginning of the file, which is considered when seeking
01052         ///         to nearest marker. In the case of objects of the interactive music hierarchy, user (wave) markers are ignored:
01053         ///         seeking occurs to the nearest segment cue (authored in the segment editor), including the Entry Cue, but excluding the Exit Cue.
01054         ///     - This method posts a command in the sound engine queue, thus seeking will not occur before 
01055         ///         the audio thread consumes it (after a call to RenderAudio()). 
01056         ///
01057         /// Notes specific to Music Segments:
01058         ///     - With Music Segments, in_iPosition is relative to the Entry Cue, in milliseconds. Use a negative
01059         ///         value to seek within the Pre-Entry.
01060         ///     - Music segments cannot be looped. You may want to listen to the AK_EndOfEvent notification 
01061         ///         in order to restart them if required.
01062         ///     - In order to restart at the correct location, with all their tracks synchronized, Music Segments 
01063         ///         take the "look-ahead time" property of their streamed tracks into account for seeking. 
01064         ///         Consequently, the resulting position after a call to SeekOnEvent() might be earlier than the 
01065         ///         value that was passed to the method. Use <tt>AK::MusicEngine::GetPlayingSegmentInfo()</tt> to query 
01066         ///         the exact position of a segment. Also, the segment will be silent during that time
01067         ///         (so that it restarts precisely at the position that you specified). <tt>AK::MusicEngine::GetPlayingSegmentInfo()</tt> 
01068         ///         also informs you about the remaining look-ahead time. 
01069         ///
01070         /// Notes specific to Music Switch Containers:
01071         ///     - Seeking triggers a music transition towards the current (or target) segment.
01072         ///         This transition is subject to the container's transition rule that matches the current and defined in the container,
01073         ///         so the moment when seeking occurs depends on the rule's "Exit At" property. On the other hand, the starting position 
01074         ///         in the target segment depends on both the desired seeking position and the rule's "Sync To" property.
01075         ///     - If the specified time is greater than the destination segment's length, the modulo is taken.
01076         ///
01077         /// \sa
01078         /// - <tt>AK::SoundEngine::RenderAudio()</tt>
01079         /// - <tt>AK::SoundEngine::PostEvent()</tt>
01080         /// - <tt>AK::SoundEngine::GetSourcePlayPosition()</tt>
01081         /// - <tt>AK::MusicEngine::GetPlayingSegmentInfo()</tt>
01082         AK_EXTERNAPIFUNC( AKRESULT, SeekOnEvent )( 
01083             const char* in_pszEventName,                                ///< Name of the event
01084             AkGameObjectID in_gameObjectID,                             ///< Associated game object ID; use AK_INVALID_GAME_OBJECT to affect all game objects
01085             AkTimeMs in_iPosition,                                      ///< Desired position where playback should restart, in milliseconds
01086             bool in_bSeekToNearestMarker = false,                       ///< If true, the final seeking position will be made equal to the nearest marker (see note above)  
01087             AkPlayingID in_PlayingID = AK_INVALID_PLAYING_ID            ///< Specify the playing ID for the seek to be applied to. Will result in the seek happening only on active actions of the playing ID. Let it be AK_INVALID_PLAYING_ID or do not specify any, to seek on all active actions of this event ID.   
01088             );
01089 
01090         /// Seeks inside all playing objects that are referenced in Play Actions of the specified Event.
01091         /// Seek position is specified as a percentage of the sound's total duration, and takes looping into account. 
01092         ///
01093         /// Notes:
01094         ///     - This works with all objects of the actor-mixer hierarchy, and also with Music Segments and Music Switch Containers. 
01095         ///     - There is a restriction with sounds that play within a continuous sequence. Seeking is ignored 
01096         ///         if one of their ancestors is a continuous (random or sequence) container with crossfade or 
01097         ///         trigger rate transitions. Seeking is also ignored with sample-accurate transitions, unless
01098         ///         the sound that is currently playing is the first sound of the sequence.
01099         ///     - Seeking is also ignored with voices that can go virtual with "From Beginning" behavior. 
01100         ///     - in_iPosition is clamped internally to the beginning of the sound/segment.
01101         ///     - If the option "Seek to nearest marker" is used, the seeking position snaps to the nearest marker.
01102         ///         With objects of the actor-mixer hierarchy, markers are embedded in wave files by an external wave editor.
01103         ///         Note that looping regions ("sampler loop") are not considered as markers. Also, the "add file name marker" of the 
01104         ///         conversion settings dialog adds a marker at the beginning of the file, which is considered when seeking
01105         ///         to nearest marker. In the case of objects of the interactive music hierarchy, user (wave) markers are ignored:
01106         ///         seeking occurs to the nearest segment cue (authored in the segment editor), including the Entry Cue, but excluding the Exit Cue.
01107         ///     - This method posts a command in the sound engine queue, thus seeking will not occur before 
01108         ///         the audio thread consumes it (after a call to RenderAudio()). 
01109         ///
01110         /// Notes specific to Music Segments:
01111         ///     - With Music Segments, \c in_fPercent is relative to the Entry Cue, and the segment's duration is the 
01112         ///         duration between its entry and exit cues. Consequently, you cannot seek within the pre-entry or
01113         ///         post-exit of a segment using this method. Use absolute values instead.
01114         ///     - Music Segments cannot be looped. You may want to listen to the \c AK_EndOfEvent notification 
01115         ///         in order to restart them if required.
01116         ///     - In order to restart at the correct location, with all their tracks synchronized, Music Segments 
01117         ///         take the "look-ahead time" property of their streamed tracks into account for seeking. 
01118         ///         Consequently, the resulting position after a call to SeekOnEvent() might be earlier than the 
01119         ///         value that was passed to the method. Use <tt>AK::MusicEngine::GetPlayingSegmentInfo()</tt> to query 
01120         ///         the exact position of a segment. Also, the segment will be silent during the time that period
01121         ///         (so that it restarts precisely at the position that you specified). <tt>AK::MusicEngine::GetPlayingSegmentInfo()</tt> 
01122         ///         also informs you about the remaining look-ahead time. 
01123         ///
01124         /// Notes specific to Music Switch Containers:
01125         ///     - Seeking triggers a music transition towards the current (or target) segment.
01126         ///         This transition is subject to the container's transition rule that matches the current and defined in the container,
01127         ///         so the moment when seeking occurs depends on the rule's "Exit At" property. On the other hand, the starting position 
01128         ///         in the target segment depends on both the desired seeking position and the rule's "Sync To" property.
01129         ///     - If the specified time is greater than the destination segment's length, the modulo is taken.
01130         ///
01131         /// \sa
01132         /// - <tt>AK::SoundEngine::RenderAudio()</tt>
01133         /// - <tt>AK::SoundEngine::PostEvent()</tt>
01134         /// - <tt>AK::SoundEngine::GetSourcePlayPosition()</tt>
01135         /// - <tt>AK::MusicEngine::GetPlayingSegmentInfo()</tt>
01136         AK_EXTERNAPIFUNC( AKRESULT, SeekOnEvent )( 
01137             AkUniqueID in_eventID,                                      ///< Unique ID of the event
01138             AkGameObjectID in_gameObjectID ,                            ///< Associated game object ID; use AK_INVALID_GAME_OBJECT to affect all game objects
01139             AkReal32 in_fPercent,                                       ///< Desired position where playback should restart, expressed in a percentage of the file's total duration, between 0 and 1.f (see note above about infinite looping sounds)
01140             bool in_bSeekToNearestMarker = false,                       ///< If true, the final seeking position will be made equal to the nearest marker (see note above)  
01141             AkPlayingID in_PlayingID = AK_INVALID_PLAYING_ID            ///< Specify the playing ID for the seek to be applied to. Will result in the seek happening only on active actions of the playing ID. Let it be AK_INVALID_PLAYING_ID or do not specify any, to seek on all active actions of this event ID.   
01142             );
01143 
01144 #ifdef AK_SUPPORT_WCHAR
01145         /// Seeks inside all playing objects that are referenced in Play Actions of the specified Event.
01146         /// Seek position is specified as a percentage of the sound's total duration, and takes looping into account. 
01147         ///
01148         /// Notes:
01149         ///     - This works with all objects of the actor-mixer hierarchy, and also with Music Segments and Music Switch Containers. 
01150         ///     - There is a restriction with sounds that play within a continuous sequence. Seeking is ignored 
01151         ///         if one of their ancestors is a continuous (random or sequence) container with crossfade or 
01152         ///         trigger rate transitions. Seeking is also ignored with sample-accurate transitions, unless
01153         ///         the sound that is currently playing is the first sound of the sequence.
01154         ///     - Seeking is also ignored with voices that can go virtual with "From Beginning" behavior. 
01155         ///     - If the option "Seek to nearest marker" is used, the seeking position snaps to the nearest marker.
01156         ///         With objects of the actor-mixer hierarchy, markers are embedded in wave files by an external wave editor.
01157         ///         Note that looping regions ("sampler loop") are not considered as markers. Also, the "add file name marker" of the 
01158         ///         conversion settings dialog adds a marker at the beginning of the file, which is considered when seeking
01159         ///         to nearest marker. In the case of objects of the interactive music hierarchy, user (wave) markers are ignored:
01160         ///         seeking occurs to the nearest segment cue (authored in the segment editor), including the Entry Cue, but excluding the Exit Cue.
01161         ///     - This method posts a command in the sound engine queue, thus seeking will not occur before 
01162         ///         the audio thread consumes it (after a call to RenderAudio()). 
01163         ///
01164         /// Notes specific to Music Segments:
01165         ///     - With Music Segments, \c in_fPercent is relative to the Entry Cue, and the segment's duration is the 
01166         ///         duration between its entry and exit cues. Consequently, you cannot seek within the pre-entry or
01167         ///         post-exit of a segment using this method. Use absolute values instead.
01168         ///     - Music Segments cannot be looped. You may want to listen to the \c AK_EndOfEvent notification 
01169         ///         in order to restart them if required.
01170         ///     - In order to restart at the correct location, with all their tracks synchronized, Music Segments 
01171         ///         take the "look-ahead time" property of their streamed tracks into account for seeking. 
01172         ///         Consequently, the resulting position after a call to SeekOnEvent() might be earlier than the 
01173         ///         value that was passed to the method. Use <tt>AK::MusicEngine::GetPlayingSegmentInfo()</tt> to query 
01174         ///         the exact position of a segment. Also, the segment will be silent during the time that period
01175         ///         (so that it restarts precisely at the position that you specified). <tt>AK::MusicEngine::GetPlayingSegmentInfo()</tt> 
01176         ///         also informs you about the remaining look-ahead time. 
01177         ///
01178         /// Notes specific to Music Switch Containers:
01179         ///     - Seeking triggers a music transition towards the current (or target) segment.
01180         ///         This transition is subject to the container's transition rule that matches the current and defined in the container,
01181         ///         so the moment when seeking occurs depends on the rule's "Exit At" property. On the other hand, the starting position 
01182         ///         in the target segment depends on both the desired seeking position and the rule's "Sync To" property.
01183         ///     - If the specified time is greater than the destination segment's length, the modulo is taken.
01184         ///
01185         /// \sa
01186         /// - <tt>AK::SoundEngine::RenderAudio()</tt>
01187         /// - <tt>AK::SoundEngine::PostEvent()</tt>
01188         /// - <tt>AK::SoundEngine::GetSourcePlayPosition()</tt>
01189         /// - <tt>AK::MusicEngine::GetPlayingSegmentInfo()</tt>
01190         AK_EXTERNAPIFUNC( AKRESULT, SeekOnEvent )( 
01191             const wchar_t* in_pszEventName,                             ///< Name of the event
01192             AkGameObjectID in_gameObjectID ,                            ///< Associated game object ID; use AK_INVALID_GAME_OBJECT to affect all game objects
01193             AkReal32 in_fPercent ,                                      ///< Desired position where playback should restart, expressed in a percentage of the file's total duration, between 0 and 1.f (see note above about infinite looping sounds)
01194             bool in_bSeekToNearestMarker = false,                       ///< If true, the final seeking position will be made equal to the nearest marker (see note above)  
01195             AkPlayingID in_PlayingID = AK_INVALID_PLAYING_ID            ///< Specify the playing ID for the seek to be applied to. Will result in the seek happening only on active actions of the playing ID. Let it be AK_INVALID_PLAYING_ID or do not specify any, to seek on all active actions of this event ID.   
01196             );
01197 #endif //AK_SUPPORT_WCHAR
01198 
01199         /// Seeks inside all playing objects that are referenced in Play Actions of the specified Event.
01200         /// Seek position is specified as a percentage of the sound's total duration, and takes looping into account. 
01201         ///
01202         /// Notes:
01203         ///     - This works with all objects of the actor-mixer hierarchy, and also with Music Segments and Music Switch Containers. 
01204         ///     - There is a restriction with sounds that play within a continuous sequence. Seeking is ignored 
01205         ///         if one of their ancestors is a continuous (random or sequence) container with crossfade or 
01206         ///         trigger rate transitions. Seeking is also ignored with sample-accurate transitions, unless
01207         ///         the sound that is currently playing is the first sound of the sequence.
01208         ///     - Seeking is also ignored with voices that can go virtual with "From Beginning" behavior. 
01209         ///     - If the option "Seek to nearest marker" is used, the seeking position snaps to the nearest marker.
01210         ///         With objects of the actor-mixer hierarchy, markers are embedded in wave files by an external wave editor.
01211         ///         Note that looping regions ("sampler loop") are not considered as markers. Also, the "add file name marker" of the 
01212         ///         conversion settings dialog adds a marker at the beginning of the file, which is considered when seeking
01213         ///         to nearest marker. In the case of objects of the interactive music hierarchy, user (wave) markers are ignored:
01214         ///         seeking occurs to the nearest segment cue (authored in the segment editor), including the Entry Cue, but excluding the Exit Cue.
01215         ///     - This method posts a command in the sound engine queue, thus seeking will not occur before 
01216         ///         the audio thread consumes it (after a call to RenderAudio()). 
01217         ///
01218         /// Notes specific to Music Segments:
01219         ///     - With Music Segments, in_fPercent is relative to the Entry Cue, and the segment's duration is the 
01220         ///         duration between its entry and exit cues. Consequently, you cannot seek within the pre-entry or
01221         ///         post-exit of a segment using this method. Use absolute values instead.
01222         ///     - Music segments cannot be looped. You may want to listen to the AK_EndOfEvent notification 
01223         ///         in order to restart them if required.
01224         ///     - In order to restart at the correct location, with all their tracks synchronized, Music Segments 
01225         ///         take the "look-ahead time" property of their streamed tracks into account for seeking. 
01226         ///         Consequently, the resulting position after a call to SeekOnEvent() might be earlier than the 
01227         ///         value that was passed to the method. Use <tt>AK::MusicEngine::GetPlayingSegmentInfo()</tt> to query 
01228         ///         the exact position of a segment. Also, the segment will be silent during the time that period
01229         ///         (so that it restarts precisely at the position that you specified). <tt>AK::MusicEngine::GetPlayingSegmentInfo()</tt> 
01230         ///         also informs you about the remaining look-ahead time. 
01231         ///
01232         /// Notes specific to Music Switch Containers:
01233         ///     - Seeking triggers a music transition towards the current (or target) segment.
01234         ///         This transition is subject to the container's transition rule that matches the current and defined in the container,
01235         ///         so the moment when seeking occurs depends on the rule's "Exit At" property. On the other hand, the starting position 
01236         ///         in the target segment depends on both the desired seeking position and the rule's "Sync To" property.
01237         ///     - If the specified time is greater than the destination segment's length, the modulo is taken.
01238         ///
01239         /// \sa
01240         /// - <tt>AK::SoundEngine::RenderAudio()</tt>
01241         /// - <tt>AK::SoundEngine::PostEvent()</tt>
01242         /// - <tt>AK::SoundEngine::GetSourcePlayPosition()</tt>
01243         /// - <tt>AK::MusicEngine::GetPlayingSegmentInfo()</tt>
01244         AK_EXTERNAPIFUNC( AKRESULT, SeekOnEvent )( 
01245             const char* in_pszEventName,                                ///< Name of the event
01246             AkGameObjectID in_gameObjectID,                             ///< Associated game object ID; use AK_INVALID_GAME_OBJECT to affect all game objects
01247             AkReal32 in_fPercent,                                       ///< Desired position where playback should restart, expressed in a percentage of the file's total duration, between 0 and 1.f (see note above about infinite looping sounds)
01248             bool in_bSeekToNearestMarker = false,                       ///< If true, the final seeking position will be made equal to the nearest marker (see notes above).    
01249             AkPlayingID in_PlayingID = AK_INVALID_PLAYING_ID            ///< Specify the playing ID for the seek to be applied to. Will result in the seek happening only on active actions of the playing ID. Let it be AK_INVALID_PLAYING_ID or do not specify any, to seek on all active actions of this event ID.   
01250             );
01251 
01252         /// Cancels all Event callbacks associated with a specific callback cookie.\n
01253         /// \sa 
01254         /// - \c <tt>AK::SoundEngine::PostEvent()</tt>
01255         AK_EXTERNAPIFUNC( void, CancelEventCallbackCookie )( 
01256             void * in_pCookie                           ///< Callback cookie to be cancelled
01257             );
01258 
01259         /// Cancels all Event callbacks associated with a specific game object.\n
01260         /// \sa 
01261         /// - \c <tt>AK::SoundEngine::PostEvent()</tt>
01262         AK_EXTERNAPIFUNC( void, CancelEventCallbackGameObject )(
01263             AkGameObjectID in_gameObjectID              ///< ID of the game object to be cancelled
01264             );
01265 
01266         /// Cancels all Event callbacks for a specific playing ID.
01267         /// \sa 
01268         /// - \c <tt>AK::SoundEngine::PostEvent()</tt>
01269         AK_EXTERNAPIFUNC( void, CancelEventCallback )( 
01270             AkPlayingID in_playingID                    ///< Playing ID of the event that must not use callbacks
01271             );
01272 
01273         /// Gets the current position of the source associated with this playing ID, obtained from PostEvent(). If more than one source is playing,
01274         /// the first to play is returned.
01275         /// Notes:
01276         /// - You need to pass AK_EnableGetSourcePlayPosition to PostEvent() in order to use this function, otherwise
01277         ///     it returns AK_Fail, even if the playing ID is valid.
01278         /// - The source's position is updated at every audio frame, and the time at which this occurs is stored. 
01279         ///     When you call this function from your thread, you therefore query the position that was updated in the previous audio frame.
01280         ///     If in_bExtrapolate is true (default), the returned position is extrapolated using the elapsed time since last 
01281         ///     sound engine update and the source's playback rate.
01282         /// \return AK_Success if successful.
01283         ///         It returns AK_InvalidParameter if the provided pointer is not valid.
01284         ///         It returns AK_Fail if the playing ID is invalid (not playing yet, or finished playing).
01285         /// \sa 
01286         /// - \ref soundengine_query_pos
01287         /// - \ref concept_events
01288         AK_EXTERNAPIFUNC( AKRESULT, GetSourcePlayPosition )(
01289             AkPlayingID     in_PlayingID,               ///< Playing ID returned by <tt>AK::SoundEngine::PostEvent()</tt>
01290             AkTimeMs*       out_puPosition,             ///< Position of the source (in ms) associated with the specified playing ID
01291             bool            in_bExtrapolate = true      ///< Position is extrapolated based on time elapsed since last sound engine update.
01292             );
01293 
01294         /// Gets the current position of the sources associated with this playing ID, obtained from PostEvent().
01295         /// Notes:
01296         /// - You need to pass AK_EnableGetSourcePlayPosition to PostEvent() in order to use this function, otherwise
01297         ///     it returns AK_Fail, even if the playing ID is valid.
01298         /// - The source's position is updated at every audio frame, and the time at which this occurs is stored. 
01299         ///     When you call this function from your thread, you therefore query the position that was updated in the previous audio frame.
01300         ///     If in_bExtrapolate is true (default), the returned position is extrapolated using the elapsed time since last 
01301         ///     sound engine update and the source's playback rate.
01302         /// - If 0 is passed in for the number of entries (*in_pcPositions == 0) then only the number of positions will be returned and the
01303         ///     position array (out_puPositions) will not be updated.
01304         /// - The io_pcPositions pointer must be non-NULL.
01305         ///     out_puPositions may be NULL if *io_pcPositions == 0, otherwise it must be non-NULL.
01306         /// \return AK_Success if successful.
01307         ///         It returns AK_InvalidParameter if the provided pointers are not valid.
01308         ///         It returns AK_Fail if the playing ID is invalid (not playing yet, or finished playing).
01309         /// \sa 
01310         /// - \ref soundengine_query_pos
01311         /// - \ref concept_events
01312         AK_EXTERNAPIFUNC(AKRESULT, GetSourcePlayPositions)(
01313             AkPlayingID     in_PlayingID,               ///< Playing ID returned by <tt>AK::SoundEngine::PostEvent()</tt>
01314             AkSourcePosition* out_puPositions,          ///< Audio Node IDs and positions of sources associated with the specified playing ID
01315             AkUInt32 *      io_pcPositions,             ///< Number of entries in out_puPositions. Needs to be set to the size of the array: it is adjusted to the actual number of returned entries
01316             bool            in_bExtrapolate = true      ///< Position is extrapolated based on time elapsed since last sound engine update
01317             );
01318 
01319         /// Gets the stream buffering of the sources associated with this playing ID, obtained from PostEvent().
01320         /// Notes:
01321         /// - You need to pass AK_EnableGetSourceStreamBuffering to PostEvent() in order to use this function, otherwise
01322         ///     it returns AK_Fail, even if the playing ID is valid.
01323         /// - The sources stream buffering is updated at every audio frame. If there are multiple sources associated with this playing ID,
01324         ///     the value returned corresponds to the least buffered source. 
01325         /// - The returned buffering status out_bIsBuffering will be true If any of the sources associated with the playing ID are actively being buffered.
01326         ///     It will be false if all of them have reached the end of file, or have reached a state where they are buffered enough and streaming is temporarily idle.
01327         /// - Purely in-memory sources are excluded from this database. If all sources are in-memory, GetSourceStreamBuffering() will return AK_Fail.
01328         /// - The returned buffering amount and state is not completely accurate with some hardware-accelerated codecs. In such cases, the amount of stream buffering is generally underestimated.
01329         ///     On the other hand, it is not guaranteed that the source will be ready to produce data at the next audio frame even if out_bIsBuffering has turned to false.
01330         /// \return 
01331         /// - AK_Success if successful.
01332         /// - AK_Fail if the source data associated with this playing ID is not found, for example if PostEvent() was not called with AK_EnableGetSourceStreamBuffering, or if the header was not parsed.
01333         /// \sa 
01334         /// - \ref concept_events
01335         AK_EXTERNAPIFUNC( AKRESULT, GetSourceStreamBuffering )(
01336             AkPlayingID     in_PlayingID,               ///< Playing ID returned by <tt>AK::SoundEngine::PostEvent()</tt>
01337             AkTimeMs &      out_buffering,              ///< Returned amount of buffering (in ms) of the source (or one of the sources) associated with that playing ID
01338             bool &          out_bIsBuffering            ///< Returned buffering status of the source(s) associated with that playing ID
01339             );
01340 
01341         /// Stops the current content playing associated to the specified game object ID.
01342         /// If no game object is specified, all sounds will be stopped.
01343         AK_EXTERNAPIFUNC( void, StopAll )( 
01344             AkGameObjectID in_gameObjectID = AK_INVALID_GAME_OBJECT ///< (Optional)Specify a game object to stop only playback associated to the provided game object ID.
01345             );
01346 
01347         /// Stop the current content playing associated to the specified playing ID.
01348         AK_EXTERNAPIFUNC( void, StopPlayingID )( 
01349             AkPlayingID in_playingID,                                           ///< Playing ID to be stopped.
01350             AkTimeMs in_uTransitionDuration = 0,                                ///< Fade duration
01351             AkCurveInterpolation in_eFadeCurve = AkCurveInterpolation_Linear    ///< Curve type to be used for the transition
01352             );
01353 
01354         /// Sets the random seed value. Can be used to synchronize randomness
01355         /// across instances of the Sound Engine.
01356         /// \remark This seeds the number generator used for all container randomizations;
01357         ///         since it acts globally, this should be called right before any PostEvent
01358         ///         call where randomness synchronization is required, and cannot guarantee
01359         ///         similar results for continuous containers.
01360         AK_EXTERNAPIFUNC( void, SetRandomSeed )( 
01361             AkUInt32 in_uSeed                                                   ///< Random seed.
01362             );
01363 
01364         /// Mutes/Unmutes the busses tagged as background music.  
01365         /// This is automatically called for platforms that have user-music support.
01366         /// This function is provided to give the same behavior on platforms that don't have user-music support.
01367         AK_EXTERNAPIFUNC( void, MuteBackgroundMusic ) (
01368             bool in_bMute ///< Sets true to mute, false to unmute.
01369             );
01370         //@}
01371 
01372         /// Gets the state of the Background Music busses. This state is either set directly 
01373         /// with \c AK::SoundEngine::MuteBackgroundMusic or by the OS, if it has User Music services.
01374         /// \return true if the background music busses are muted, false if not.
01375         AK_EXTERNAPIFUNC(bool, GetBackgroundMusicMute) ();
01376         //@}
01377 
01378 
01379         /// Sends custom game data to a plug-in that resides on a bus (insert Effect or mixer plug-in).
01380         /// Data will be copied and stored into a separate list.
01381         /// Previous entry is deleted when a new one is sent.
01382         /// Sets the data pointer to NULL to clear item from the list.
01383         /// \aknote The plug-in type and ID is passed and matched with plugins set on the desired bus. 
01384         /// This means that you cannot send different data to various instances of the plug-in on a same bus.\endaknote
01385         /// \return AK_Success if data was sent successfully.
01386         AK_EXTERNAPIFUNC( AKRESULT, SendPluginCustomGameData ) (
01387             AkUniqueID in_busID,            ///< Bus ID
01388             AkGameObjectID in_busObjectID,  ///< Bus Object ID. Pass AK_INVALID_GAME_OBJECT to send custom data with global scope. Game object scope supersedes global scope, as with RTPCs. 
01389             AkPluginType in_eType,          ///< Plug-in type (for example, source or effect)
01390             AkUInt32 in_uCompanyID,     ///< Company identifier (as declared in the plug-in description XML file)
01391             AkUInt32 in_uPluginID,          ///< Plug-in identifier (as declared in the plug-in description XML file)
01392             const void* in_pData,           ///< The data blob
01393             AkUInt32 in_uSizeInBytes        ///< Size of data
01394             );
01395         //@}
01396 
01397         ////////////////////////////////////////////////////////////////////////
01398         /// @name Game Objects
01399         //@{
01400         
01401         /// Registers a game object.
01402         /// \return
01403         /// - AK_Success if successful
01404         /// - AK_Fail if the specified AkGameObjectID is invalid (0 and -1 are invalid)
01405         /// \remark Registering a game object twice does nothing. Unregistering it once unregisters it no 
01406         ///         matter how many times it has been registered.
01407         /// \sa 
01408         /// - <tt>AK::SoundEngine::UnregisterGameObj()</tt>
01409         /// - <tt>AK::SoundEngine::UnregisterAllGameObj()</tt>
01410         /// - \ref concept_gameobjects
01411         AK_EXTERNAPIFUNC(AKRESULT, RegisterGameObj)(
01412             AkGameObjectID in_gameObjectID                              ///< ID of the game object to be registered         
01413             );
01414 
01415         /// Registers a game object.
01416         /// \return
01417         /// - AK_Success if successful
01418         /// - AK_Fail if the specified AkGameObjectID is invalid (0 and -1 are invalid)
01419         /// \remark Registering a game object twice does nothing. Unregistering it once unregisters it no 
01420         ///         matter how many times it has been registered.
01421         /// \sa 
01422         /// - <tt>AK::SoundEngine::UnregisterGameObj()</tt>
01423         /// - <tt>AK::SoundEngine::UnregisterAllGameObj()</tt>
01424         /// - \ref concept_gameobjects
01425         AK_EXTERNAPIFUNC( AKRESULT, RegisterGameObj )(
01426             AkGameObjectID in_gameObjectID,                         ///< ID of the game object to be registered
01427             const char * in_pszObjName                              ///< Name of the game object (for monitoring purpose)
01428             );
01429 
01430         /// Unregisters a game object.
01431         /// \return 
01432         /// - AK_Success if successful
01433         /// - AK_Fail if the specified AkGameObjectID is invalid (0 is an invalid ID)
01434         /// \remark Registering a game object twice does nothing. Unregistering it once unregisters it no 
01435         ///         matter how many times it has been registered. Unregistering a game object while it is 
01436         ///         in use is allowed, but the control over the parameters of this game object is lost.
01437         ///         For example, say a sound associated with this game object is a 3D moving sound. This sound will 
01438         ///         stop moving when the game object is unregistered, and there will be no way to regain control over the game object.
01439         /// \sa 
01440         /// - <tt>AK::SoundEngine::RegisterGameObj()</tt>
01441         /// - <tt>AK::SoundEngine::UnregisterAllGameObj()</tt>
01442         /// - \ref concept_gameobjects
01443         AK_EXTERNAPIFUNC( AKRESULT, UnregisterGameObj )(
01444             AkGameObjectID in_gameObjectID              ///< ID of the game object to be unregistered. Use 
01445                                                         /// AK_INVALID_GAME_OBJECT to unregister all game objects.
01446             );
01447 
01448     /// Unregister all game objects, or all game objects with a particular matching set of property flags.
01449     /// This function to can be used to unregister all game objects.  
01450     /// \return
01451     /// - AK_Success if successful
01452     /// \remark Registering a game object twice does nothing. Unregistering it once unregisters it no 
01453     ///         matter how many times it has been registered. Unregistering a game object while it is 
01454     ///         in use is allowed, but the control over the parameters of this game object is lost.
01455     ///         For example, if a sound associated with this game object is a 3D moving sound, it will 
01456     ///         stop moving once the game object is unregistered, and there will be no way to recover 
01457     ///         the control over this game object.
01458     /// \sa 
01459     /// - <tt>AK::SoundEngine::RegisterGameObj()</tt>
01460     /// - <tt>AK::SoundEngine::UnregisterGameObj()</tt>
01461     /// - \ref concept_gameobjects
01462     AK_EXTERNAPIFUNC( AKRESULT, UnregisterAllGameObj )(
01463         );
01464 
01465         /// Sets the position of a game object.
01466         /// \warning The object's orientation vector (in_Position.Orientation) must be normalized.
01467         /// \return 
01468         /// - AK_Success when successful
01469         /// - AK_InvalidParameter if parameters are not valid.
01470         /// \sa 
01471         /// - \ref soundengine_3dpositions
01472         AK_EXTERNAPIFUNC( AKRESULT, SetPosition )( 
01473             AkGameObjectID in_GameObjectID,     ///< Game Object identifier
01474             const AkSoundPosition & in_Position ///< Position to set; in_Position.Orientation must be normalized.
01475             );
01476 
01477         /// Sets multiple positions to a single game object.
01478         /// Setting multiple positions on a single game object is a way to simulate multiple emission sources while using the resources of only one voice.
01479         /// This can be used to simulate wall openings, area sounds, or multiple objects emitting the same sound in the same area.
01480         /// \aknote Calling <tt>AK::SoundEngine::SetMultiplePositions()</tt> with only one position is the same as calling <tt>AK::SoundEngine::SetPosition()</tt> \endaknote
01481         /// \return 
01482         /// - AK_Success when successful
01483         /// - AK_InvalidParameter if parameters are not valid.
01484         /// \sa 
01485         /// - \ref soundengine_3dpositions
01486         /// - \ref soundengine_3dpositions_multiplepos
01487         /// - \ref AK::SoundEngine::MultiPositionType
01488         AK_EXTERNAPIFUNC( AKRESULT, SetMultiplePositions )( 
01489             AkGameObjectID in_GameObjectID,                     ///< Game Object identifier.
01490             const AkSoundPosition * in_pPositions,              ///< Array of positions to apply.
01491             AkUInt16 in_NumPositions,                           ///< Number of positions specified in the provided array.
01492             MultiPositionType in_eMultiPositionType = MultiPositionType_MultiDirections ///< \ref AK::SoundEngine::MultiPositionType
01493             );
01494 
01495         /// Sets multiple positions to a single game object, with flexible assignment of input channels.
01496         /// Setting multiple positions on a single game object is a way to simulate multiple emission sources while using the resources of only one voice.
01497         /// This can be used to simulate wall openings, area sounds, or multiple objects emitting the same sound in the same area.
01498         /// \aknote Calling <tt>AK::SoundEngine::SetMultiplePositions()</tt> with only one position is the same as calling <tt>AK::SoundEngine::SetPosition()</tt> \endaknote
01499         /// \return 
01500         /// - AK_Success when successful
01501         /// - AK_InvalidParameter if parameters are not valid.
01502         /// \sa 
01503         /// - \ref soundengine_3dpositions
01504         /// - \ref soundengine_3dpositions_multiplepos
01505         /// - \ref AK::SoundEngine::MultiPositionType
01506         AK_EXTERNAPIFUNC( AKRESULT, SetMultiplePositions )( 
01507             AkGameObjectID in_GameObjectID,                     ///< Game Object identifier.
01508             const AkChannelEmitter * in_pPositions,         ///< Array of positions to apply.
01509             AkUInt16 in_NumPositions,                           ///< Number of positions specified in the provided array.
01510             MultiPositionType in_eMultiPositionType = MultiPositionType_MultiDirections ///< \ref AK::SoundEngine::MultiPositionType
01511             );
01512 
01513         /// Sets the scaling factor of a Game Object.
01514         /// Modify the attenuation computations on this Game Object to simulate sounds with a larger or smaller area of effect.
01515         /// \return 
01516         /// - AK_Success when successful
01517         /// - AK_InvalidParameter if the scaling factor specified was 0 or negative.
01518         AK_EXTERNAPIFUNC( AKRESULT, SetScalingFactor )(
01519             AkGameObjectID in_GameObjectID,             ///< Game object identifier
01520             AkReal32 in_fAttenuationScalingFactor       ///< Scaling Factor, 1 means 100%, 0.5 means 50%, 2 means 200%, and so on.
01521             );
01522 
01523         //@}
01524 
01525         ////////////////////////////////////////////////////////////////////////
01526         /// @name Bank Management
01527         //@{
01528 
01529         /// Unload all currently loaded banks.
01530         /// It also internally calls ClearPreparedEvents() since at least one bank must have been loaded to allow preparing events.
01531         /// \return 
01532         /// - AK_Success if successful
01533         /// - AK_Fail if the sound engine was not correctly initialized or if there is not enough memory to handle the command
01534         /// \sa 
01535         /// - <tt>AK::SoundEngine::UnloadBank()</tt>
01536         /// - <tt>AK::SoundEngine::LoadBank()</tt>
01537         /// - \ref soundengine_banks
01538         AK_EXTERNAPIFUNC( AKRESULT, ClearBanks )();
01539 
01540         /// Sets the I/O settings of the bank load and prepare event processes.
01541         /// The sound engine uses default values unless explicitly set by calling this method.
01542         /// \warning This function must be called before loading banks.
01543         /// \return 
01544         /// - AK_Success if successful
01545         /// - AK_Fail if the sound engine was not correctly initialized
01546         /// - AK_InvalidParameter if some parameters are invalid
01547         /// \sa 
01548         /// - \ref soundengine_banks
01549         /// - \ref streamingdevicemanager
01550         AK_EXTERNAPIFUNC( AKRESULT, SetBankLoadIOSettings )(
01551             AkReal32            in_fThroughput,         ///< Average throughput of bank data streaming (bytes/ms) (the default value is AK_DEFAULT_BANK_THROUGHPUT)
01552             AkPriority          in_priority             ///< Priority of bank streaming (the default value is AK_DEFAULT_PRIORITY)
01553             );
01554 
01555 #ifdef AK_SUPPORT_WCHAR
01556         /// Load a bank synchronously (by Unicode string).\n
01557         /// The bank name is passed to the Stream Manager.
01558         /// Refer to \ref soundengine_banks_general for a discussion on using strings and IDs.
01559         /// You can specify a custom pool for storage of media, the engine will create a new pool if AK_DEFAULT_POOL_ID is passed.
01560         /// A bank load request will be posted, and consumed by the Bank Manager thread.
01561         /// The function returns when the request has been completely processed.
01562         /// \return 
01563         /// The bank ID, which is obtained by hashing the bank name (see GetIDFromString()). 
01564         /// You may use this ID with UnloadBank().
01565         /// - AK_Success: Load or unload successful.
01566         /// - AK_InsufficientMemory: Insufficient memory to store bank data.
01567         /// - AK_BankReadError: I/O error.
01568         /// - AK_WrongBankVersion: Invalid bank version: make sure the version of Wwise that 
01569         /// you used to generate the SoundBanks matches that of the SDK you are currently using.
01570         /// - AK_InvalidFile: File specified could not be opened.
01571         /// - AK_InvalidParameter: Invalid parameter, invalid memory alignment.     
01572         /// - AK_Fail: Load or unload failed for any other reason. (Most likely small allocation failure)
01573         /// \remarks
01574         /// - The initialization bank must be loaded first.
01575         /// - All SoundBanks subsequently loaded must come from the same Wwise project as the
01576         ///   initialization bank. If you need to load SoundBanks from a different project, you
01577         ///   must first unload ALL banks, including the initialization bank, then load the
01578         ///   initialization bank from the other project, and finally load banks from that project.
01579         /// - Codecs and plug-ins must be registered before loading banks that use them.
01580         /// - Loading a bank referencing an unregistered plug-in or codec will result in a load bank success,
01581         /// but the plug-ins will not be used. More specifically, playing a sound that uses an unregistered effect plug-in 
01582         /// will result in audio playback without applying the said effect. If an unregistered source plug-in is used by an event's audio objects, 
01583         /// posting the event will fail.
01584         /// - The sound engine internally calls GetIDFromString(in_pszString) to return the correct bank ID.
01585         /// Therefore, in_pszString should be the real name of the SoundBank (with or without the BNK extension - it is trimmed internally),
01586         /// not the name of the file (if you changed it), nor the full path of the file. The path should be resolved in 
01587         /// your implementation of the Stream Manager, or in the Low-Level I/O module if you use the default Stream Manager's implementation.
01588         /// - Requesting to load a bank in a different memory pool than where the bank was previously loaded must be done only
01589         /// after receiving confirmation by the callback that the bank was completely unloaded or by using synchronous versions
01590         /// of the UnloadBank() function.
01591         /// \sa 
01592         /// - <tt>AK::SoundEngine::UnloadBank()</tt>
01593         /// - <tt>AK::SoundEngine::ClearBanks()</tt>
01594         /// - <tt>AK::SoundEngine::GetIDFromString()</tt>
01595         /// - <tt>AK::MemoryMgr::CreatePool()</tt>
01596         /// - \ref soundengine_banks
01597         /// - \ref integrating_elements_plugins
01598         /// - \ref streamingdevicemanager
01599         /// - \ref streamingmanager_lowlevel
01600         /// - \ref sdk_bank_training
01601         AK_EXTERNAPIFUNC( AKRESULT, LoadBank )(
01602             const wchar_t*      in_pszString,           ///< Name of the bank to load
01603             AkMemPoolId         in_memPoolId,           ///< Memory pool ID (the pool is created if AK_DEFAULT_POOL_ID is passed)
01604             AkBankID &          out_bankID              ///< Returned bank ID
01605             );
01606 #endif //AK_SUPPORT_WCHAR
01607 
01608         /// Loads a bank synchronously.\n
01609         /// The bank name is passed to the Stream Manager.
01610         /// Refer to \ref soundengine_banks_general for a discussion on using strings and IDs.
01611         /// You can specify a custom pool for storage of media, the engine will create a new pool if AK_DEFAULT_POOL_ID is passed.
01612         /// A bank load request will be posted, and consumed by the Bank Manager thread.
01613         /// The function returns when the request has been completely processed.
01614         /// \return 
01615         /// The bank ID, which is obtained by hashing the bank name (see GetIDFromString()). 
01616         /// You may use this ID with UnloadBank().
01617         /// - AK_Success: Load or unload successful.
01618         /// - AK_InsufficientMemory: Insufficient memory to store bank data.
01619         /// - AK_BankReadError: I/O error.
01620         /// - AK_WrongBankVersion: Invalid bank version: make sure the version of Wwise that 
01621         /// you used to generate the SoundBanks matches that of the SDK you are currently using.
01622         /// - AK_InvalidFile: File specified could not be opened.
01623         /// - AK_InvalidParameter: Invalid parameter, invalid memory alignment.     
01624         /// - AK_Fail: Load or unload failed for any other reason. (Most likely small allocation failure)
01625         /// \remarks
01626         /// - The initialization bank must be loaded first.
01627         /// - All SoundBanks subsequently loaded must come from the same Wwise project as the
01628         ///   initialization bank. If you need to load SoundBanks from a different project, you
01629         ///   must first unload ALL banks, including the initialization bank, then load the
01630         ///   initialization bank from the other project, and finally load banks from that project.
01631         /// - Codecs and plug-ins must be registered before loading banks that use them.
01632         /// - Loading a bank referencing an unregistered plug-in or codec will result in a load bank success,
01633         /// but the plug-ins will not be used. More specifically, playing a sound that uses an unregistered effect plug-in 
01634         /// will result in audio playback without applying the said effect. If an unregistered source plug-in is used by an event's audio objects, 
01635         /// posting the event will fail.
01636         /// - The sound engine internally calls GetIDFromString(in_pszString) to return the correct bank ID.
01637         /// Therefore, in_pszString should be the real name of the SoundBank (with or without the BNK extension - it is trimmed internally),
01638         /// not the name of the file (if you changed it), nor the full path of the file. The path should be resolved in 
01639         /// your implementation of the Stream Manager, or in the Low-Level I/O module if you use the default Stream Manager's implementation.
01640         /// - Requesting to load a bank in a different memory pool than where the bank was previously loaded must be done only
01641         /// after receiving confirmation by the callback that the bank was completely unloaded or by using synchronous versions
01642         /// of the UnloadBank() function.
01643         /// \sa 
01644         /// - <tt>AK::SoundEngine::UnloadBank()</tt>
01645         /// - <tt>AK::SoundEngine::ClearBanks()</tt>
01646         /// - <tt>AK::SoundEngine::GetIDFromString</tt>
01647         /// - <tt>AK::MemoryMgr::CreatePool()</tt>
01648         /// - \ref soundengine_banks
01649         /// - \ref integrating_elements_plugins
01650         /// - \ref streamingdevicemanager
01651         /// - \ref streamingmanager_lowlevel
01652         /// - \ref sdk_bank_training
01653         AK_EXTERNAPIFUNC( AKRESULT, LoadBank )(
01654             const char*         in_pszString,           ///< Name of the bank to load
01655             AkMemPoolId         in_memPoolId,           ///< Memory pool ID (the pool is created if AK_DEFAULT_POOL_ID is passed)
01656             AkBankID &          out_bankID              ///< Returned bank ID
01657             );
01658 
01659         /// Loads a bank synchronously (by ID).\n
01660         /// \aknote Requires that the "Use SoundBank names" option be unchecked in the Wwise Project Settings. \endaknote
01661         /// The bank ID is passed to the Stream Manager.
01662         /// Refer to \ref soundengine_banks_general for a discussion on using strings and IDs.
01663         /// You can specify a custom pool for storage of media, the engine will create a new pool if AK_DEFAULT_POOL_ID is passed.
01664         /// A bank load request will be posted, and consumed by the Bank Manager thread.
01665         /// The function returns when the request has been completely processed.
01666         /// \return 
01667         /// - AK_Success: Load or unload successful.
01668         /// - AK_InsufficientMemory: Insufficient memory to store bank data.
01669         /// - AK_BankReadError: I/O error.
01670         /// - AK_WrongBankVersion: Invalid bank version: make sure the version of Wwise that 
01671         /// you used to generate the SoundBanks matches that of the SDK you are currently using.
01672         /// - AK_InvalidFile: File specified could not be opened.
01673         /// - AK_InvalidParameter: Invalid parameter, invalid memory alignment.     
01674         /// - AK_Fail: Load or unload failed for any other reason. (Most likely small allocation failure)
01675         /// \remarks
01676         /// - The initialization bank must be loaded first.
01677         /// - All SoundBanks subsequently loaded must come from the same Wwise project as the
01678         ///   initialization bank. If you need to load SoundBanks from a different project, you
01679         ///   must first unload ALL banks, including the initialization bank, then load the
01680         ///   initialization bank from the other project, and finally load banks from that project.
01681         /// - Codecs and plug-ins must be registered before loading banks that use them.
01682         /// - Loading a bank referencing an unregistered plug-in or codec will result in a load bank success,
01683         /// but the plug-ins will not be used. More specifically, playing a sound that uses an unregistered effect plug-in 
01684         /// will result in audio playback without applying the said effect. If an unregistered source plug-in is used by an event's audio objects, 
01685         /// posting the event will fail.
01686         /// - Requesting to load a bank in a different memory pool than where the bank was previously loaded must be done only
01687         /// after receiving confirmation by the callback that the bank was completely unloaded or by using synchronous versions
01688         /// of the UnloadBank function.
01689         /// \sa 
01690         /// - <tt>AK::SoundEngine::UnloadBank()</tt>
01691         /// - <tt>AK::SoundEngine::ClearBanks()</tt>
01692         /// - <tt>AK::MemoryMgr::CreatePool()</tt>
01693         /// - \ref soundengine_banks
01694         /// - \ref integrating_elements_plugins
01695         /// - \ref sdk_bank_training
01696         AK_EXTERNAPIFUNC( AKRESULT, LoadBank )(
01697             AkBankID            in_bankID,              ///< Bank ID of the bank to load
01698             AkMemPoolId         in_memPoolId            ///< Memory pool ID (the pool is created if AK_DEFAULT_POOL_ID is passed)
01699             );
01700 
01701         /// Loads a bank synchronously (from in-memory data, in-place).\n
01702         ///
01703         /// IMPORTANT: Banks loaded from memory with in-place data MUST be unloaded using the UnloadBank function
01704         /// providing the same memory pointer. Make sure you are using the correct UnloadBank(...) overload
01705         ///
01706         /// Use this overload when you want to manage I/O on your side. Load the bank file
01707         /// in a buffer and pass its address to the sound engine.
01708         /// In-memory loading is in-place: *** the memory must be valid until the bank is unloaded. ***
01709         /// A bank load request will be posted, and consumed by the Bank Manager thread.
01710         /// The function returns when the request has been completely processed.
01711         /// \return 
01712         /// The bank ID, which is stored in the first few bytes of the bank file. You may use this 
01713         /// ID with UnloadBank().
01714         /// - AK_Success: Load or unload successful.
01715         /// - AK_InsufficientMemory: Insufficient memory to store bank data.
01716         /// - AK_BankReadError: I/O error.
01717         /// - AK_WrongBankVersion: Invalid bank version: make sure the version of Wwise that 
01718         /// you used to generate the SoundBanks matches that of the SDK you are currently using.
01719         /// - AK_InvalidFile: File specified could not be opened.
01720         /// - AK_InvalidParameter: Invalid parameter, invalid memory alignment.     
01721         /// - AK_Fail: Load or unload failed for any other reason. (Most likely small allocation failure)
01722         /// \remarks
01723         /// - The initialization bank must be loaded first.
01724         /// - All SoundBanks subsequently loaded must come from the same Wwise project as the
01725         ///   initialization bank. If you need to load SoundBanks from a different project, you
01726         ///   must first unload ALL banks, including the initialization bank, then load the
01727         ///   initialization bank from the other project, and finally load banks from that project.
01728         /// - Codecs and plug-ins must be registered before loading banks that use them.
01729         /// - Loading a bank referencing an unregistered plug-in or codec will result in a load bank success,
01730         /// but the plug-ins will not be used. More specifically, playing a sound that uses an unregistered effect plug-in 
01731         /// will result in audio playback without applying the said effect. If an unregistered source plug-in is used by an event's audio objects, 
01732         /// posting the event will fail.
01733         /// - The memory must be aligned on platform-specific AK_BANK_PLATFORM_DATA_ALIGNMENT bytes (see AkTypes.h).
01734         /// - (XboxOne only): If the bank may contain XMA in memory data, the memory must be allocated using the Physical memory allocator.
01735         /// - Requesting to load a bank in a different memory pool than where the bank was previously loaded must be done only
01736         /// after receiving confirmation by the callback that the bank was completely unloaded or by using synchronous versions
01737         /// of the UnloadBank function.
01738         /// - Avoid using this function for banks containing a lot of events or structure data.  
01739         ///   This data will be loaded in the Default Pool anyway thus duplicating memory (one copy in the Default Pool 
01740         ///   and one in the block you provided). For event/structure-only banks, prefer the other versions of LoadBank().
01741         /// \sa 
01742         /// - <tt>AK::SoundEngine::UnloadBank()</tt>
01743         /// - <tt>AK::SoundEngine::ClearBanks()</tt>
01744         /// - \ref soundengine_banks
01745         /// - \ref integrating_elements_plugins
01746         /// - \ref sdk_bank_training
01747         AK_EXTERNAPIFUNC( AKRESULT, LoadBank )(
01748             const void *        in_pInMemoryBankPtr,    ///< Pointer to the in-memory bank to load (pointer is stored in sound engine, memory must remain valid)
01749             AkUInt32            in_uInMemoryBankSize,   ///< Size of the in-memory bank to load
01750             AkBankID &          out_bankID              ///< Returned bank ID
01751             );
01752 
01753         /// Loads a bank synchronously (from in-memory data, out-of-place).\n
01754         ///
01755         /// NOTE: Banks loaded from in-memory with out-of-place data must be unloaded using the standard UnloadBank function
01756         /// (with no memory pointer). Make sure you are using the correct UnloadBank(...) overload
01757         ///
01758         /// Use this overload when you want to manage I/O on your side. Load the bank file
01759         /// in a buffer and pass its address to the sound engine, the media section of the bank will be copied into the 
01760         /// specified memory pool.  
01761         /// In-memory loading is out-of-place: the buffer can be release as soon as the function returns. The advantage of using this
01762         /// over the in-place version is that there is no duplication of bank structures.
01763         /// A bank load request will be posted, and consumed by the Bank Manager thread.
01764         /// The function returns when the request has been completely processed.
01765         /// \return 
01766         /// The bank ID, which is stored in the first few bytes of the bank file. You may use this 
01767         /// ID with UnloadBank().
01768         /// - AK_Success: Load or unload successful.
01769         /// - AK_InsufficientMemory: Insufficient memory to store bank data.
01770         /// - AK_BankReadError: I/O error.
01771         /// - AK_WrongBankVersion: Invalid bank version: make sure the version of Wwise that 
01772         /// you used to generate the SoundBanks matches that of the SDK you are currently using.
01773         /// - AK_InvalidFile: File specified could not be opened.
01774         /// - AK_InvalidParameter: Invalid parameter, invalid memory alignment.     
01775         /// - AK_Fail: Load or unload failed for any other reason. (Most likely small allocation failure)
01776         /// \remarks
01777         /// - The initialization bank must be loaded first.
01778         /// - All SoundBanks subsequently loaded must come from the same Wwise project as the
01779         ///   initialization bank. If you need to load SoundBanks from a different project, you
01780         ///   must first unload ALL banks, including the initialization bank, then load the
01781         ///   initialization bank from the other project, and finally load banks from that project.
01782         /// - Codecs and plug-ins must be registered before loading banks that use them.
01783         /// - Loading a bank referencing an unregistered plug-in or codec will result in a load bank success,
01784         /// but the plug-ins will not be used. More specifically, playing a sound that uses an unregistered effect plug-in 
01785         /// will result in audio playback without applying the said effect. If an unregistered source plug-in is used by an event's audio objects, 
01786         /// posting the event will fail.
01787         /// - The memory must be aligned on platform-specific AK_BANK_PLATFORM_DATA_ALIGNMENT bytes (see AkTypes.h).
01788         /// - (XboxOne only): If the bank may contain XMA in memory data, the memory must be allocated using the Physical memory allocator.
01789         /// - Requesting to load a bank in a different memory pool than where the bank was previously loaded must be done only
01790         /// after receiving confirmation by the callback that the bank was completely unloaded or by using synchronous versions
01791         /// of the UnloadBank function.
01792         /// - Avoid using this function for banks containing a lot of events or structure data.  
01793         ///   This data will be loaded in the Default Pool anyway thus duplicating memory (one copy in the Default Pool 
01794         ///   and one in the block you provided). For event/structure-only banks, prefer the other versions of LoadBank().
01795         /// \sa 
01796         /// - <tt>AK::SoundEngine::UnloadBank()</tt>
01797         /// - <tt>AK::SoundEngine::ClearBanks()</tt>
01798         /// - \ref soundengine_banks
01799         /// - \ref integrating_elements_plugins
01800         /// - \ref sdk_bank_training
01801         AK_EXTERNAPIFUNC( AKRESULT, LoadBank )(
01802             const void *        in_pInMemoryBankPtr,    ///< Pointer to the in-memory bank to load (pointer is not stored in sound engine, memory can be released after return)
01803             AkUInt32            in_uInMemoryBankSize,   ///< Size of the in-memory bank to load
01804             AkMemPoolId         in_uPoolForBankMedia,   ///< Memory pool to copy the media section of the bank to (the pool is created if AK_DEFAULT_POOL_ID is passed).
01805             AkBankID &          out_bankID              ///< Returned bank ID
01806             );
01807 
01808         /// Synchronously decodes Vorbis-encoded and Opus-encoded (Software version) media in a SoundBank. The file should already be read in memory before the decode operation. The out_pDecodedBankPtr can then be used with variants of LoadBank that load from in-memory data.
01809         /// \n
01810         /// CPU usage, RAM size, storage size and Internet bandwidth must be accounted for when developing a game, especially when it is aimed at mobile platforms. The DecodeBank function makes it possible to decode media at load time instead of decoding them every time they are played.
01811         AK_EXTERNAPIFUNC( AKRESULT, DecodeBank )(
01812             const void *        in_pInMemoryBankPtr,    ///< Pointer to the in-memory bank to decode (pointer is not stored in sound engine, memory can be released after return)
01813             AkUInt32            in_uInMemoryBankSize,   ///< Size of the in-memory bank to decode
01814             AkMemPoolId         in_uPoolForDecodedBank, ///< Memory pool to allocate decoded bank into. Specify AK_INVALID_POOL_ID and out_pDecodedBankPtr=NULL to obtain decoded bank size without performing the decode operation. Pass AK_INVALID_POOL_ID and out_pDecodedBankPtr!=NULL to decode bank into specified pointer.
01815             void * &            out_pDecodedBankPtr,    ///< Decoded bank memory location.
01816             AkUInt32 &          out_uDecodedBankSize    ///< Decoded bank memory size.
01817             );
01818 
01819 #ifdef AK_SUPPORT_WCHAR
01820         /// Loads a bank asynchronously (by Unicode string).\n
01821         /// The bank name is passed to the Stream Manager.
01822         /// Refer to \ref soundengine_banks_general for a discussion on using strings and IDs.
01823         /// You can specify a custom pool for storage of media, the engine will create a new pool if AK_DEFAULT_POOL_ID is passed.
01824         /// A bank load request will be posted to the Bank Manager consumer thread.
01825         /// The function returns immediately.
01826         /// \return 
01827         /// AK_Success if the scheduling was successful, AK_Fail otherwise.
01828         /// Use a callback to be notified when completed, and get the status of the request.
01829         /// The bank ID, which is obtained by hashing the bank name (see GetIDFromString()). 
01830         /// You may use this ID with UnloadBank().
01831         /// \remarks
01832         /// - The initialization bank must be loaded first.
01833         /// - All SoundBanks subsequently loaded must come from the same Wwise project as the
01834         ///   initialization bank. If you need to load SoundBanks from a different project, you
01835         ///   must first unload ALL banks, including the initialization bank, then load the
01836         ///   initialization bank from the other project, and finally load banks from that project.
01837         /// - Codecs and plug-ins must be registered before loading banks that use them.
01838         /// - Loading a bank referencing an unregistered plug-in or codec will result in a load bank success,
01839         /// but the plug-ins will not be used. More specifically, playing a sound that uses an unregistered effect plug-in 
01840         /// will result in audio playback without applying the said effect. If an unregistered source plug-in is used by an event's audio objects, 
01841         /// posting the event will fail.
01842         /// - The sound engine internally calls GetIDFromString(in_pszString) to return the correct bank ID.
01843         /// Therefore, in_pszString should be the real name of the SoundBank (with or without the BNK extension - it is trimmed internally),
01844         /// not the name of the file (if you changed it), nor the full path of the file. The path should be resolved in 
01845         /// your implementation of the Stream Manager (<tt>AK::IAkStreamMgr::CreateStd()</tt>), or in the Low-Level I/O module 
01846         /// (<tt>AK::StreamMgr::IAkFileLocationResolver::Open()</tt>) if you use the default Stream Manager's implementation.
01847         /// - The cookie (in_pCookie) is passed to the Low-Level I/O module for your convenience, in <tt>AK::StreamMgr::IAkFileLocationResolver::Open()</tt> 
01848         // as AkFileSystemFlags::pCustomParam.
01849         /// - Requesting to load a bank in a different memory pool than where the bank was previously loaded must be done only
01850         /// after receiving confirmation by the callback that the bank was completely unloaded or by using synchronous versions
01851         /// of the UnloadBank function.
01852         /// \sa 
01853         /// - <tt>AK::SoundEngine::UnloadBank()</tt>
01854         /// - <tt>AK::SoundEngine::ClearBanks()</tt>
01855         /// - <tt>AK::MemoryMgr::CreatePool()</tt>
01856         /// - AkBankCallbackFunc
01857         /// - \ref soundengine_banks
01858         /// - \ref integrating_elements_plugins
01859         /// - \ref streamingdevicemanager
01860         /// - \ref streamingmanager_lowlevel
01861         /// - \ref sdk_bank_training
01862         AK_EXTERNAPIFUNC( AKRESULT, LoadBank )(
01863             const wchar_t*      in_pszString,           ///< Name/path of the bank to load
01864             AkBankCallbackFunc  in_pfnBankCallback,     ///< Callback function
01865             void *              in_pCookie,             ///< Callback cookie (reserved to user, passed to the callback function, and also to  <tt>AK::StreamMgr::IAkFileLocationResolver::Open()</tt> as AkFileSystemFlags::pCustomParam)
01866             AkMemPoolId         in_memPoolId,           ///< Memory pool ID (the pool is created if AK_DEFAULT_POOL_ID is passed)
01867             AkBankID &          out_bankID              ///< Returned bank ID
01868             );
01869 #endif //AK_SUPPORT_WCHAR
01870 
01871         /// Loads a bank asynchronously.\n
01872         /// The bank name is passed to the Stream Manager.
01873         /// Refer to \ref soundengine_banks_general for a discussion on using strings and IDs.
01874         /// You can specify a custom pool for storage of media, the engine will create a new pool if AK_DEFAULT_POOL_ID is passed.
01875         /// A bank load request will be posted to the Bank Manager consumer thread.
01876         /// The function returns immediately.
01877         /// \return 
01878         /// AK_Success if the scheduling was successful, AK_Fail otherwise.
01879         /// Use a callback to be notified when completed, and get the status of the request.
01880         /// The bank ID, which is obtained by hashing the bank name (see GetIDFromString()). 
01881         /// You may use this ID with UnloadBank().
01882         /// \remarks
01883         /// - The initialization bank must be loaded first.
01884         /// - All SoundBanks subsequently loaded must come from the same Wwise project as the
01885         ///   initialization bank. If you need to load SoundBanks from a different project, you
01886         ///   must first unload ALL banks, including the initialization bank, then load the
01887         ///   initialization bank from the other project, and finally load banks from that project.
01888         /// - Codecs and plug-ins must be registered before loading banks that use them.
01889         /// - Loading a bank referencing an unregistered plug-in or codec will result in a load bank success,
01890         /// but the plug-ins will not be used. More specifically, playing a sound that uses an unregistered effect plug-in 
01891         /// will result in audio playback without applying the said effect. If an unregistered source plug-in is used by an event's audio objects, 
01892         /// posting the Event will fail.
01893         /// - The sound engine internally calls GetIDFromString(in_pszString) to return the correct bank ID.
01894         /// Therefore, \c in_pszString should be the real name of the SoundBank (with or without the BNK extension - it is trimmed internally),
01895         /// not the name of the file (if you changed it), nor the full path of the file. The path should be resolved in 
01896         /// your implementation of the Stream Manager (<tt>AK::IAkStreamMgr::CreateStd()</tt>), or in the Low-Level I/O module 
01897         /// (<tt>AK::StreamMgr::IAkFileLocationResolver::Open()</tt>) if you use the default Stream Manager's implementation.
01898         /// - The cookie (in_pCookie) is passed to the Low-Level I/O module for your convenience, in <tt>AK::StreamMgr::IAkFileLocationResolver::Open()</tt> 
01899         // as <tt>AkFileSystemFlags::pCustomParam</tt>.
01900         /// - Requesting to load a bank in a different memory pool than where the bank was previously loaded must be done only
01901         /// after receiving confirmation by the callback that the bank was completely unloaded or by using synchronous versions
01902         /// of the \c UnloadBank function.
01903         /// \sa 
01904         /// - <tt>AK::SoundEngine::UnloadBank()</tt>
01905         /// - <tt>AK::SoundEngine::ClearBanks()</tt>
01906         /// - <tt>AK::MemoryMgr::CreatePool()</tt>
01907         /// - AkBankCallbackFunc
01908         /// - \ref soundengine_banks
01909         /// - \ref integrating_elements_plugins
01910         /// - \ref streamingdevicemanager
01911         /// - \ref streamingmanager_lowlevel
01912         /// - \ref sdk_bank_training
01913         AK_EXTERNAPIFUNC( AKRESULT, LoadBank )(
01914             const char*         in_pszString,           ///< Name/path of the bank to load
01915             AkBankCallbackFunc  in_pfnBankCallback,     ///< Callback function
01916             void *              in_pCookie,             ///< Callback cookie (reserved to user, passed to the callback function, and also to  <tt>AK::StreamMgr::IAkFileLocationResolver::Open()</tt> as AkFileSystemFlags::pCustomParam)
01917             AkMemPoolId         in_memPoolId,           ///< Memory pool ID (the pool is created if AK_DEFAULT_POOL_ID is passed)
01918             AkBankID &          out_bankID              ///< Returned bank ID
01919             );
01920 
01921         /// Loads a bank asynchronously (by ID).\n
01922         /// \aknote Requires that the "Use SoundBank names" option be unchecked in the Wwise Project Settings. \endaknote
01923         /// The bank ID is passed to the Stream Manager.
01924         /// Refer to \ref soundengine_banks_general for a discussion on using strings and IDs.
01925         /// You can specify a custom pool for storage of media, the engine will create a new pool if AK_DEFAULT_POOL_ID is passed.
01926         /// A bank load request will be posted to the Bank Manager consumer thread.
01927         /// The function returns immediately.
01928         /// \return 
01929         /// AK_Success if the scheduling was successful, AK_Fail otherwise.
01930         /// Use a callback to be notified when completed, and get the status of the request.
01931         /// The bank ID, which is obtained by hashing the bank name (see GetIDFromString()). 
01932         /// You may use this ID with \c UnloadBank().
01933         /// \remarks
01934         /// - The initialization bank must be loaded first.
01935         /// - All SoundBanks subsequently loaded must come from the same Wwise project as the
01936         ///   initialization bank. If you need to load SoundBanks from a different project, you
01937         ///   must first unload ALL banks, including the initialization bank, then load the
01938         ///   initialization bank from the other project, and finally load banks from that project.
01939         /// - Codecs and plug-ins must be registered before loading banks that use them.
01940         /// - Loading a bank referencing an unregistered plug-in or codec will result in a load bank success,
01941         /// but the plug-ins will not be used. More specifically, playing a sound that uses an unregistered effect plug-in 
01942         /// will result in audio playback without applying the said effect. If an unregistered source plug-in is used by an event's audio objects, 
01943         /// posting the event will fail.
01944         /// - The file path should be resolved in your implementation of the Stream Manager, or in the Low-Level I/O module if 
01945         /// you use the default Stream Manager's implementation. The ID overload of <tt>AK::IAkStreamMgr::CreateStd()</tt> and <tt>AK::StreamMgr::IAkFileLocationResolver::Open()</tt> are called.
01946         /// - The cookie (in_pCookie) is passed to the Low-Level I/O module for your convenience, in <tt>AK::StreamMgr::IAkFileLocationResolver::Open()</tt> 
01947         // as AkFileSystemFlags::pCustomParam.
01948         /// - Requesting to load a bank in a different memory pool than where the bank was previously loaded must be done only
01949         /// after receiving confirmation by the callback that the bank was completely unloaded or by using synchronous versions
01950         /// of the UnloadBank function.
01951         /// \sa 
01952         /// - <tt>AK::SoundEngine::UnloadBank()</tt>
01953         /// - <tt>AK::SoundEngine::ClearBanks()</tt>
01954         /// - <tt>AK::MemoryMgr::CreatePool()</tt>
01955         /// - AkBankCallbackFunc
01956         /// - \ref soundengine_banks
01957         /// - \ref integrating_elements_plugins
01958         /// - \ref sdk_bank_training
01959         AK_EXTERNAPIFUNC( AKRESULT, LoadBank )(
01960             AkBankID            in_bankID,              ///< Bank ID of the bank to load
01961             AkBankCallbackFunc  in_pfnBankCallback,     ///< Callback function
01962             void *              in_pCookie,             ///< Callback cookie (reserved to user, passed to the callback function, and also to  <tt>AK::StreamMgr::IAkFileLocationResolver::Open()</tt> as AkFileSystemFlags::pCustomParam)
01963             AkMemPoolId         in_memPoolId            ///< Memory pool ID (the pool is created if AK_DEFAULT_POOL_ID is passed)
01964             );
01965 
01966         /// Loads a bank asynchronously (from in-memory data, in-place).\n
01967         ///
01968         /// IMPORTANT: Banks loaded from memory with in-place data MUST be unloaded using the UnloadBank function
01969         /// providing the same memory pointer. Make sure you are using the correct UnloadBank(...) overload
01970         ///
01971         /// Use this overload when you want to manage I/O on your side. Load the bank file
01972         /// in a buffer and pass its address to the sound engine.
01973         /// In-memory loading is in-place: *** the memory must be valid until the bank is unloaded. ***
01974         /// A bank load request will be posted to the Bank Manager consumer thread.
01975         /// The function returns immediately.
01976         /// \return 
01977         /// AK_Success if the scheduling was successful, AK_Fail otherwise, or AK_InvalidParameter if memory alignment is not correct.
01978         /// Use a callback to be notified when completed, and get the status of the request.
01979         /// The bank ID, which is obtained by hashing the bank name (see GetIDFromString()). 
01980         /// You may use this ID with UnloadBank().
01981         /// \remarks
01982         /// - The initialization bank must be loaded first.
01983         /// - All SoundBanks subsequently loaded must come from the same Wwise project as the
01984         ///   initialization bank. If you need to load SoundBanks from a different project, you
01985         ///   must first unload ALL banks, including the initialization bank, then load the
01986         ///   initialization bank from the other project, and finally load banks from that project.
01987         /// - Codecs and plug-ins must be registered before loading banks that use them.
01988         /// - Loading a bank referencing an unregistered plug-in or codec will result in a load bank success,
01989         /// but the plug-ins will not be used. More specifically, playing a sound that uses an unregistered effect plug-in 
01990         /// will result in audio playback without applying the said effect. If an unregistered source plug-in is used by an event's audio objects, 
01991         /// posting the event will fail.
01992         /// - The memory must be aligned on platform-specific AK_BANK_PLATFORM_DATA_ALIGNMENT bytes (see AkTypes.h).
01993         /// - (XboxOne only): If the bank may contain XMA in memory data, the memory must be allocated using the Physical memory allocator.
01994         /// - Requesting to load a bank in a different memory pool than where the bank was previously loaded must be done only
01995         /// after receiving confirmation by the callback that the bank was completely unloaded or by using synchronous versions
01996         /// of the UnloadBank function.
01997         /// \sa 
01998         /// - <tt>AK::SoundEngine::UnloadBank()</tt>
01999         /// - <tt>AK::SoundEngine::ClearBanks()</tt>
02000         /// - AkBankCallbackFunc
02001         /// - \ref soundengine_banks
02002         /// - \ref integrating_elements_plugins
02003         /// - \ref sdk_bank_training
02004         AK_EXTERNAPIFUNC( AKRESULT, LoadBank )(
02005             const void *        in_pInMemoryBankPtr,    ///< Pointer to the in-memory bank to load (pointer is stored in sound engine, memory must remain valid)
02006             AkUInt32            in_uInMemoryBankSize,   ///< Size of the in-memory bank to load
02007             AkBankCallbackFunc  in_pfnBankCallback,     ///< Callback function
02008             void *              in_pCookie,             ///< Callback cookie
02009             AkBankID &          out_bankID              ///< Returned bank ID
02010             );
02011 
02012         /// Loads a bank asynchronously (from in-memory data, out-of-place).\n
02013         ///
02014         /// NOTE: Banks loaded from in-memory with out-of-place data must be unloaded using the standard UnloadBank function
02015         /// (with no memory pointer). Make sure you are using the correct UnloadBank(...) overload
02016         ///
02017         /// Use this overload when you want to manage I/O on your side. Load the bank file
02018         /// in a buffer and pass its address to the sound engine, the media section of the bank will be copied into the 
02019         /// specified memory pool.  
02020         /// In-memory loading is out-of-place: the buffer can be released after the callback function is called. The advantage of using this
02021         /// over the in-place version is that there is no duplication of bank structures.
02022         /// A bank load request will be posted to the Bank Manager consumer thread.
02023         /// The function returns immediately.
02024         /// \return 
02025         /// AK_Success if the scheduling was successful, AK_Fail otherwise, or AK_InvalidParameter if memory alignment is not correct.
02026         /// Use a callback to be notified when completed, and get the status of the request.
02027         /// The bank ID, which is obtained by hashing the bank name (see GetIDFromString()). 
02028         /// You may use this ID with UnloadBank().
02029         /// \remarks
02030         /// - The initialization bank must be loaded first.
02031         /// - All SoundBanks subsequently loaded must come from the same Wwise project as the
02032         ///   initialization bank. If you need to load SoundBanks from a different project, you
02033         ///   must first unload ALL banks, including the initialization bank, then load the
02034         ///   initialization bank from the other project, and finally load banks from that project.
02035         /// - Codecs and plug-ins must be registered before loading banks that use them.
02036         /// - Loading a bank referencing an unregistered plug-in or codec will result in a load bank success,
02037         /// but the plug-ins will not be used. More specifically, playing a sound that uses an unregistered effect plug-in 
02038         /// will result in audio playback without applying the said effect. If an unregistered source plug-in is used by an event's audio objects, 
02039         /// posting the event will fail.
02040         /// - The memory must be aligned on platform-specific AK_BANK_PLATFORM_DATA_ALIGNMENT bytes (see AkTypes.h).
02041         /// - (XboxOne only): If the bank may contain XMA in memory data, the memory must be allocated using the Physical memory allocator.
02042         /// - Requesting to load a bank in a different memory pool than where the bank was previously loaded must be done only
02043         /// after receiving confirmation by the callback that the bank was completely unloaded or by using synchronous versions
02044         /// of the UnloadBank function.
02045         /// \sa 
02046         /// - <tt>AK::SoundEngine::UnloadBank()</tt>
02047         /// - <tt>AK::SoundEngine::ClearBanks()</tt>
02048         /// - AkBankCallbackFunc
02049         /// - \ref soundengine_banks
02050         /// - \ref integrating_elements_plugins
02051         /// - \ref sdk_bank_training
02052         AK_EXTERNAPIFUNC( AKRESULT, LoadBank )(
02053             const void *        in_pInMemoryBankPtr,    ///< Pointer to the in-memory bank to load (pointer is not stored in sound engine, memory can be released after callback)
02054             AkUInt32            in_uInMemoryBankSize,   ///< Size of the in-memory bank to load
02055             AkBankCallbackFunc  in_pfnBankCallback,     ///< Callback function
02056             void *              in_pCookie,             ///< Callback cookie
02057             AkMemPoolId         in_uPoolForBankMedia,   ///< Memory pool to copy the media section of the bank to (the pool is created if AK_DEFAULT_POOL_ID is passed).
02058             AkBankID &          out_bankID              ///< Returned bank ID
02059             );
02060 
02061 #ifdef AK_SUPPORT_WCHAR
02062         /// Unloads a bank synchronously (by Unicode string).\n
02063         /// Refer to \ref soundengine_banks_general for a discussion on using strings and IDs.
02064         /// \return AK_Success if successful, AK_Fail otherwise. AK_Success is returned when the bank was not loaded.
02065         /// \remarks
02066         /// - If you provided a pool memory ID when loading this bank, it is returned as well. 
02067         /// Otherwise, the function returns AK_DEFAULT_POOL_ID.
02068         /// - The sound engine internally calls GetIDFromString(in_pszString) to retrieve the bank ID, 
02069         /// then it calls the synchronous version of UnloadBank() by ID.
02070         /// Therefore, in_pszString should be the real name of the SoundBank (with or without the BNK extension - it is trimmed internally),
02071         /// not the name of the file (if you changed it), nor the full path of the file. 
02072         /// - In order to force the memory deallocation of the bank, sounds that use media from this bank will be stopped. 
02073         /// This means that streamed sounds or generated sounds will not be stopped.
02074         /// \sa 
02075         /// - <tt>AK::SoundEngine::LoadBank()</tt>
02076         /// - <tt>AK::SoundEngine::ClearBanks()</tt>
02077         /// - \ref soundengine_banks
02078         AK_EXTERNAPIFUNC( AKRESULT, UnloadBank )(
02079             const wchar_t*      in_pszString,           ///< Name of the bank to unload
02080             const void *        in_pInMemoryBankPtr,    ///< Memory pointer from where the bank was initially loaded from. (REQUIRED to determine which bank associated to a memory pointer must be unloaded). Pass NULL only if NULL was passed when loading the bank.
02081             AkMemPoolId *       out_pMemPoolId = NULL   ///< Returned memory pool ID used with LoadBank() (can pass NULL)
02082             );
02083 #endif //AK_SUPPORT_WCHAR
02084 
02085         /// Unloads a bank synchronously.\n
02086         /// Refer to \ref soundengine_banks_general for a discussion on using strings and IDs.
02087         /// \return AK_Success if successful, AK_Fail otherwise. AK_Success is returned when the bank was not loaded.
02088         /// \remarks
02089         /// - If you provided a pool memory ID when loading this bank, it is returned as well. 
02090         /// Otherwise, the function returns AK_DEFAULT_POOL_ID.
02091         /// - The sound engine internally calls GetIDFromString(in_pszString) to retrieve the bank ID, 
02092         /// then it calls the synchronous version of UnloadBank() by ID.
02093         /// Therefore, in_pszString should be the real name of the SoundBank (with or without the BNK extension - it is trimmed internally),
02094         /// not the name of the file (if you changed it), nor the full path of the file. 
02095         /// - In order to force the memory deallocation of the bank, sounds that use media from this bank will be stopped. 
02096         /// This means that streamed sounds or generated sounds will not be stopped.
02097         /// \sa 
02098         /// - <tt>AK::SoundEngine::LoadBank()</tt>
02099         /// - <tt>AK::SoundEngine::ClearBanks()</tt>
02100         /// - \ref soundengine_banks
02101         AK_EXTERNAPIFUNC( AKRESULT, UnloadBank )(
02102             const char*         in_pszString,           ///< Name of the bank to unload
02103             const void *        in_pInMemoryBankPtr,    ///< Memory pointer from where the bank was initially loaded from. (REQUIRED to determine which bank associated to a memory pointer must be unloaded). Pass NULL only if NULL was passed when loading the bank.
02104             AkMemPoolId *       out_pMemPoolId = NULL   ///< Returned memory pool ID used with LoadBank() (can pass NULL)
02105             );
02106 
02107         /// Unloads a bank synchronously (by ID and memory pointer).\n
02108         /// \return AK_Success if successful, AK_Fail otherwise. AK_Success is returned when the bank was not loaded.
02109         /// \remarks
02110         /// If you provided a pool memory ID when loading this bank, it is returned as well. 
02111         /// Otherwise, the function returns AK_DEFAULT_POOL_ID.
02112         /// - In order to force the memory deallocation of the bank, sounds that use media from this bank will be stopped. 
02113         /// This means that streamed sounds or generated sounds will not be stopped.
02114         /// \sa 
02115         /// - <tt>AK::SoundEngine::LoadBank()</tt>
02116         /// - <tt>AK::SoundEngine::ClearBanks()</tt>
02117         /// - \ref soundengine_banks
02118         AK_EXTERNAPIFUNC( AKRESULT, UnloadBank )(
02119             AkBankID            in_bankID,              ///< ID of the bank to unload
02120             const void *        in_pInMemoryBankPtr,    ///< Memory pointer from where the bank was initially loaded from. (REQUIRED to determine which bank associated to a memory pointer must be unloaded). Pass NULL only if NULL was passed when loading the bank.
02121             AkMemPoolId *       out_pMemPoolId = NULL   ///< Returned memory pool ID used with LoadBank() (can pass NULL)
02122             );
02123 
02124 #ifdef AK_SUPPORT_WCHAR
02125         /// Unloads a bank asynchronously (by Unicode string).\n
02126         /// Refer to \ref soundengine_banks_general for a discussion on using strings and IDs.
02127         /// \return AK_Success if scheduling successful (use a callback to be notified when completed)
02128         /// \remarks
02129         /// The sound engine internally calls GetIDFromString(in_pszString) to retrieve the bank ID, 
02130         /// then it calls the synchronous version of UnloadBank() by ID.
02131         /// Therefore, in_pszString should be the real name of the SoundBank (with or without the BNK extension - it is trimmed internally),
02132         /// not the name of the file (if you changed it), nor the full path of the file. 
02133         /// - In order to force the memory deallocation of the bank, sounds that use media from this bank will be stopped. 
02134         /// This means that streamed sounds or generated sounds will not be stopped.
02135         /// \sa 
02136         /// - <tt>AK::SoundEngine::LoadBank()</tt>
02137         /// - <tt>AK::SoundEngine::ClearBanks()</tt>
02138         /// - AkBankCallbackFunc
02139         /// - \ref soundengine_banks
02140         AK_EXTERNAPIFUNC( AKRESULT, UnloadBank )(
02141             const wchar_t*      in_pszString,           ///< Name of the bank to unload
02142             const void *        in_pInMemoryBankPtr,    ///< Memory pointer from where the bank was initially loaded from. (REQUIRED to determine which bank associated to a memory pointer must be unloaded). Pass NULL only if NULL was passed when loading the bank.
02143             AkBankCallbackFunc  in_pfnBankCallback,     ///< Callback function
02144             void *              in_pCookie              ///< Callback cookie (reserved to user, passed to the callback function)
02145             );
02146 #endif //AK_SUPPORT_WCHAR
02147 
02148         /// Unloads a bank asynchronously.\n
02149         /// Refer to \ref soundengine_banks_general for a discussion on using strings and IDs.
02150         /// \return AK_Success if scheduling successful (use a callback to be notified when completed)
02151         /// \remarks
02152         /// The sound engine internally calls GetIDFromString(in_pszString) to retrieve the bank ID, 
02153         /// then it calls the synchronous version of UnloadBank() by ID.
02154         /// Therefore, in_pszString should be the real name of the SoundBank (with or without the BNK extension - it is trimmed internally),
02155         /// not the name of the file (if you changed it), nor the full path of the file. 
02156         /// - In order to force the memory deallocation of the bank, sounds that use media from this bank will be stopped. 
02157         /// This means that streamed sounds or generated sounds will not be stopped.
02158         /// \sa 
02159         /// - <tt>AK::SoundEngine::LoadBank()</tt>
02160         /// - <tt>AK::SoundEngine::ClearBanks()</tt>
02161         /// - AkBankCallbackFunc
02162         /// - \ref soundengine_banks
02163         AK_EXTERNAPIFUNC( AKRESULT, UnloadBank )(
02164             const char*         in_pszString,           ///< Name of the bank to unload
02165             const void *        in_pInMemoryBankPtr,    ///< Memory pointer from where the bank was initially loaded from. (REQUIRED to determine which bank associated to a memory pointer must be unloaded). Pass NULL only if NULL was passed when loading the bank.
02166             AkBankCallbackFunc  in_pfnBankCallback,     ///< Callback function
02167             void *              in_pCookie              ///< Callback cookie (reserved to user, passed to the callback function)
02168             );
02169 
02170         /// Unloads a bank asynchronously (by ID and memory pointer).\n
02171         /// Refer to \ref soundengine_banks_general for a discussion on using strings and IDs.
02172         /// \return AK_Success if scheduling successful (use a callback to be notified when completed)
02173         /// \remarks
02174         /// - In order to force the memory deallocation of the bank, sounds that use media from this bank will be stopped. 
02175         /// This means that streamed sounds or generated sounds will not be stopped.
02176         /// \sa 
02177         /// - <tt>AK::SoundEngine::LoadBank()</tt>
02178         /// - <tt>AK::SoundEngine::ClearBanks()</tt>
02179         /// - AkBankCallbackFunc
02180         /// - \ref soundengine_banks
02181         AK_EXTERNAPIFUNC( AKRESULT, UnloadBank )(
02182             AkBankID            in_bankID,              ///< ID of the bank to unload
02183             const void *        in_pInMemoryBankPtr,    ///< Memory pointer from where the bank was initially loaded from. (REQUIRED to determine which bank associated to a memory pointer must be unloaded). Pass NULL only if NULL was passed when loading the bank.
02184             AkBankCallbackFunc  in_pfnBankCallback,     ///< Callback function
02185             void *              in_pCookie              ///< Callback cookie (reserved to user, passed to the callback function)
02186             );
02187 
02188         /// Cancels all Event callbacks associated with a specific callback cookie specified while loading Banks of preparing Events.\n
02189         /// \sa 
02190         /// - <tt>AK::SoundEngine::LoadBank()</tt>
02191         /// - <tt>AK::SoundEngine::PrepareEvent()</tt>
02192         /// - <tt>AK::SoundEngine::UnloadBank()</tt>
02193         /// - <tt>AK::SoundEngine::ClearBanks()</tt>
02194         /// - AkBankCallbackFunc
02195         AK_EXTERNAPIFUNC( void, CancelBankCallbackCookie )( 
02196             void * in_pCookie                           ///< Callback cookie to be canceled
02197             );
02198 
02199         /// Preparation type.
02200         /// \sa
02201         /// - <tt>AK::SoundEngine::PrepareEvent()</tt>
02202         /// - <tt>AK::SoundEngine::PrepareGameSyncs()</tt>
02203         /// - <tt>AK::SoundEngine::PrepareBank()</tt>
02204         enum PreparationType
02205         {
02206             Preparation_Load,   ///< \c PrepareEvent() will load required information to play the specified event.
02207             Preparation_Unload, ///< \c PrepareEvent() will unload required information to play the specified event.
02208             Preparation_LoadAndDecode ///< Vorbis media is decoded when loading, and an uncompressed PCM version is used for playback.
02209         };
02210 
02211         /// Parameter to be passed to <tt>AK::SoundEngine::PrepareBank()</tt>.
02212         /// Use AkBankContent_All to load both the media and structural content from the bank. 
02213         /// Use AkBankContent_StructureOnly to load only the structural content, including events, from the bank and then later use the PrepareEvent() functions to load media on demand from loose files on the disk.
02214         /// \sa 
02215         /// - <tt>AK::SoundEngine::PrepareBank()</tt>
02216         /// - \ref soundengine_banks_preparingbanks
02217         enum AkBankContent
02218         {
02219             AkBankContent_StructureOnly,    ///< Use AkBankContent_StructureOnly to load only the structural content, including Events, and then later use the PrepareEvent() functions to load media on demand from loose files on the disk.
02220             AkBankContent_All               ///< Use AkBankContent_All to load both the media and structural content.
02221         };
02222 
02223 #ifdef AK_SUPPORT_WCHAR
02224         /// This function will load the Events, structural content, and optionally, the media content from the SoundBank. If the flag AkBankContent_All is specified, PrepareBank() will load the media content from 
02225         /// the bank; but, as opposed to LoadBank(), the media will be loaded one media item at a time instead of in one contiguous memory block. Using PrepareBank(), alone or in combination with PrepareEvent(), 
02226         /// will prevent in-memory duplication of media at the cost of some memory fragmentation.
02227         /// Calling this function specifying the flag AkBankContent_StructureOnly will load only the structural part (including events) of this bank, 
02228         /// allowing using PrepareEvent() to load media on demand.  
02229         /// \sa 
02230         /// - \ref soundengine_banks_preparingbanks
02231         /// - <tt>AK::SoundEngine::LoadBank()</tt>
02232         /// - <tt>AK::SoundEngine::PreparationType</tt>
02233         /// \remarks
02234         /// PrepareBank(), when called with the flag AkBankContent_StructureOnly, requires additional calls to PrepareEvent() to load the media for each event. PrepareEvent(), however, is unable to 
02235         ///     access media content contained within SoundBanks and requires that the media be available as loose files in the file system. This flag may be useful to implement multiple loading configurations;
02236         /// for example, a game may have a tool mode that uses PrepareEvent() to load loose files on-demand and, also, a game mode that uses LoadBank() to load the bank in entirety.
02237         AK_EXTERNAPIFUNC( AKRESULT, PrepareBank )(
02238             AK::SoundEngine::PreparationType    in_PreparationType,         ///< Preparation type ( Preparation_Load or Preparation_Unload )
02239             const wchar_t*        in_pszString,                             ///< Name of the bank to Prepare/Unprepare.
02240             AK::SoundEngine::AkBankContent  in_uFlags = AkBankContent_All   ///< Structures only (including events) or all content.
02241             );
02242 #endif //AK_SUPPORT_WCHAR
02243 
02244         /// This function will load the Events, structural content, and optionally, the media content from the SoundBank. If the flag AkBankContent_All is specified, PrepareBank() will load the media content from 
02245         /// the bank; but, as opposed to LoadBank(), the media will be loaded one media item at a time instead of in one contiguous memory block. Using PrepareBank(), alone or in combination with PrepareEvent(), 
02246         /// will prevent in-memory duplication of media at the cost of some memory fragmentation.
02247         /// Calling this function specifying the flag AkBankContent_StructureOnly will load only the structural part (including events) of this bank, 
02248         /// allowing using PrepareEvent() to load media on demand.  
02249         /// \sa 
02250         /// - \ref soundengine_banks_preparingbanks
02251         /// - <tt>AK::SoundEngine::LoadBank()</tt>
02252         /// - <tt>AK::SoundEngine::PreparationType</tt>
02253         /// \remarks
02254         /// \c PrepareBank(), when called with the flag \c AkBankContent_StructureOnly, requires additional calls to \c PrepareEvent() to load the media for each event. \c PrepareEvent(), however, is unable to 
02255         ///     access media content contained within SoundBanks and requires that the media be available as loose files in the file system. This flag may be useful to implement multiple loading configurations;
02256         ///     for example, a game may have a tool mode that uses PrepareEvent() to load loose files on-demand and, also, a game mode that uses \c LoadBank() to load the bank in entirety.
02257         AK_EXTERNAPIFUNC( AKRESULT, PrepareBank )(
02258             AK::SoundEngine::PreparationType    in_PreparationType,         ///< Preparation type ( Preparation_Load or Preparation_Unload )
02259             const char*           in_pszString,                             ///< Name of the bank to Prepare/Unprepare.
02260             AK::SoundEngine::AkBankContent  in_uFlags = AkBankContent_All   ///< Structures only (including events) or all content.
02261             );
02262 
02263         /// \n\aknote Requires that the "Use SoundBank names" option be unchecked in the Wwise Project Settings. \endaknote
02264         /// This function will load the events, structural content, and optionally, the media content from the SoundBank. If the flag AkBankContent_All is specified, PrepareBank() will load the media content from 
02265         /// the bank, but as opposed to LoadBank(), the media will be loaded one media item at a time instead of in one contiguous memory block. Using PrepareBank(), alone or in combination with PrepareEvent(), 
02266         /// will prevent in-memory duplication of media at the cost of some memory fragmentation.
02267         /// Calling this function specifying the flag AkBankContent_StructureOnly will load only the structural part (including events) of this bank, 
02268         /// allowing using PrepareEvent() to load media on demand.  
02269         /// \sa 
02270         /// - \ref soundengine_banks_preparingbanks
02271         /// - <tt>AK::SoundEngine::LoadBank()</tt>
02272         /// - <tt>AK::SoundEngine::PreparationType</tt>
02273         /// \remarks
02274         /// \c PrepareBank(), when called with the flag AkBankContent_StructureOnly, requires additional calls to PrepareEvent() to load the media for each event. PrepareEvent(), however, is unable to 
02275         ///     access media content contained within SoundBanks and requires that the media be available as loose files in the file system. This flag may be useful to implement multiple loading configurations;
02276         ///     for example, a game may have a tool mode that uses PrepareEvent() to load loose files on-demand and, also, a game mode that uses LoadBank() to load the bank in entirety.
02277         AK_EXTERNAPIFUNC( AKRESULT, PrepareBank )(
02278             AK::SoundEngine::PreparationType    in_PreparationType,         ///< Preparation type ( Preparation_Load or Preparation_Unload )
02279             AkBankID            in_bankID,                                  ///< ID of the bank to Prepare/Unprepare.
02280             AK::SoundEngine::AkBankContent  in_uFlags = AkBankContent_All   ///< Structures only (including events) or all content.
02281             );
02282 
02283 #ifdef AK_SUPPORT_WCHAR
02284         /// This function will load the Events, structural content, and optionally, the media content from the SoundBank. If the flag AkBankContent_All is specified, PrepareBank() will load the media content from 
02285         /// the bank, but as opposed to LoadBank(), the media will be loaded one media item at a time instead of in one contiguous memory block. Using PrepareBank(), alone or in combination with PrepareEvent(), 
02286         /// will prevent in-memory duplication of media at the cost of some memory fragmentation.
02287         /// Calling this function specifying the flag AkBankContent_StructureOnly will load only the structural part (including events) of this bank, 
02288         /// allowing using PrepareEvent() to load media on demand.  
02289         /// \sa 
02290         /// - \ref soundengine_banks_preparingbanks
02291         /// - <tt>AK::SoundEngine::LoadBank()</tt>
02292         /// - <tt>AK::SoundEngine::PreparationType</tt>
02293         /// \remarks
02294         /// PrepareBank(), when called with the flag AkBankContent_StructureOnly, requires additional calls to PrepareEvent() to load the media for each event. PrepareEvent(), however, is unable to 
02295         ///     access media content contained within SoundBanks and requires that the media be available as loose files in the file system. This flag may be useful to implement multiple loading configurations;
02296         ///     for example, a game may have a tool mode that uses PrepareEvent() to load loose files on-demand and, also, a game mode that uses LoadBank() to load the bank in entirety.
02297         AK_EXTERNAPIFUNC( AKRESULT, PrepareBank )(
02298             AK::SoundEngine::PreparationType    in_PreparationType,         ///< Preparation type ( Preparation_Load or Preparation_Unload )
02299             const wchar_t*      in_pszString,                               ///< Name of the bank to Prepare/Unprepare.
02300             AkBankCallbackFunc  in_pfnBankCallback,                         ///< Callback function
02301             void *              in_pCookie,                                 ///< Callback cookie (reserved to user, passed to the callback function)
02302             AK::SoundEngine::AkBankContent  in_uFlags = AkBankContent_All   ///< Structures only (including events) or all content.
02303             );
02304 #endif //AK_SUPPORT_WCHAR
02305 
02306         /// This function will load the events, structural content, and optionally, the media content from the SoundBank. If the flag \c AkBankContent_All is specified, \c PrepareBank() will load the media content from 
02307         /// the bank, but as opposed to \c LoadBank(), the media will be loaded one media item at a time instead of in one contiguous memory block. Using \c PrepareBank(), alone or in combination with PrepareEvent(), 
02308         /// will prevent in-memory duplication of media at the cost of some memory fragmentation.
02309         /// Calling this function specifying the flag AkBankContent_StructureOnly will load only the structural part (including events) of this bank, 
02310         /// allowing using PrepareEvent() to load media on demand.  
02311         /// \sa 
02312         /// - \ref soundengine_banks_preparingbanks
02313         /// - <tt>AK::SoundEngine::LoadBank()</tt>
02314         /// - <tt>AK::SoundEngine::PreparationType()</tt>
02315         /// \remarks
02316         /// PrepareBank(), when called with the flag AkBankContent_StructureOnly, requires additional calls to PrepareEvent() to load the media for each event. PrepareEvent(), however, is unable to 
02317         ///     access media content contained within SoundBanks and requires that the media be available as loose files in the file system. This flag may be useful to implement multiple loading configurations;
02318         ///     for example, a game may have a tool mode that uses PrepareEvent() to load loose files on-demand and, also, a game mode that uses LoadBank() to load the bank in entirety.
02319         AK_EXTERNAPIFUNC( AKRESULT, PrepareBank )(
02320             AK::SoundEngine::PreparationType    in_PreparationType,         ///< Preparation type ( Preparation_Load or Preparation_Unload )
02321             const char*         in_pszString,                               ///< Name of the bank to Prepare/Unprepare.
02322             AkBankCallbackFunc  in_pfnBankCallback,                         ///< Callback function
02323             void *              in_pCookie,                                 ///< Callback cookie (reserved to user, passed to the callback function)
02324             AK::SoundEngine::AkBankContent  in_uFlags = AkBankContent_All   ///< Structures only (including events) or all content.
02325             );
02326 
02327         /// \n\aknote Requires that the "Use SoundBank names" option be unchecked in the Wwise Project Settings. \endaknote
02328         /// This function will load the events, structural content, and optionally, the media content from the SoundBank. If the flag AkBankContent_All is specified, \c PrepareBank() will load the media content from 
02329         /// the bank, but as opposed to \c LoadBank(), the media will be loaded one media item at a time instead of in one contiguous memory block. Using \c PrepareBank(), alone or in combination with \c PrepareEvent(), 
02330         /// will prevent in-memory duplication of media at the cost of some memory fragmentation.
02331         /// Calling this function specifying the flag AkBankContent_StructureOnly will load only the structural part (including events) of this bank, 
02332         /// allowing using PrepareEvent() to load media on demand.  
02333         /// \sa 
02334         /// - \ref soundengine_banks_preparingbanks
02335         /// - <tt>AK::SoundEngine::LoadBank()</tt>
02336         /// - <tt>AK::SoundEngine::PreparationType()</tt>
02337         /// \remarks
02338         /// \c PrepareBank(), when called with the flag AkBankContent_StructureOnly, requires additional calls to PrepareEvent() to load the media for each event. \c PrepareEvent(), however, is unable to 
02339         ///     access media content contained within SoundBanks and requires that the media be available as loose files in the file system. This flag may be useful to implement multiple loading configurations;
02340         ///     for example, a game may have a tool mode that uses \c PrepareEvent() to load loose files on-demand and, also, a game mode that uses \c LoadBank() to load the bank in entirety.
02341         AK_EXTERNAPIFUNC( AKRESULT, PrepareBank )(
02342             AK::SoundEngine::PreparationType        in_PreparationType,             ///< Preparation type ( Preparation_Load or Preparation_Unload )
02343             AkBankID            in_bankID,                      ///< ID of the bank to Prepare/Unprepare.
02344             AkBankCallbackFunc  in_pfnBankCallback,             ///< Callback function
02345             void *              in_pCookie,                     ///< Callback cookie (reserved to user, passed to the callback function)
02346             AK::SoundEngine::AkBankContent      in_uFlags = AkBankContent_All   ///< Structures only (including events) or all content.
02347             );
02348         
02349         /// Clear all previously prepared events.\n
02350         /// \return
02351         /// - AK_Success if successful.
02352         /// - AK_Fail if the sound engine was not correctly initialized or if there is not enough memory to handle the command.
02353         /// \remarks
02354         /// The function \c ClearBanks() also clears all prepared events.
02355         /// \sa
02356         /// - \c <tt>AK::SoundEngine::PrepareEvent()</tt>
02357         /// - \c <tt>AK::SoundEngine::ClearBanks()</tt>
02358         AK_EXTERNAPIFUNC( AKRESULT, ClearPreparedEvents )();
02359 
02360 #ifdef AK_SUPPORT_WCHAR
02361         /// Prepares or unprepares Events synchronously (by Unicode string).\n
02362         /// The Events are identified by strings, and converted to IDs internally
02363         /// (refer to \ref soundengine_banks_general for a discussion on using strings and IDs).
02364         /// Before invoking \c PrepareEvent(), use \c LoadBank() to explicitly load the SoundBank(s) 
02365         /// that contain the Events and structures. When a request is posted to the
02366         /// Bank Manager consumer thread, it will resolve all dependencies needed to 
02367         /// successfully post the specified Events and load the required loose media files. 
02368         /// \aknote Before version 2015.1, the required media files could be included
02369         /// in a separate media SoundBank. As described in \ref whatsnew_2015_1_migration,
02370         /// however,\c  PrepareEvent() now only looks for loose media files.
02371         /// \endaknote
02372         /// The function returns when the request is completely processed.
02373         /// \return 
02374         /// - AK_Success: Prepare/un-prepare successful.
02375         /// - AK_IDNotFound: At least one of the event/game sync identifiers passed to PrepareEvent() does not exist.
02376         /// - AK_InsufficientMemory: Insufficient memory to store bank data.
02377         /// - AK_BankReadError: I/O error.
02378         /// - AK_WrongBankVersion: Invalid bank version: make sure the version of Wwise that 
02379         /// you used to generate the SoundBanks matches that of the SDK you are currently using.
02380         /// - AK_InvalidFile: File specified could not be opened.
02381         /// - AK_InvalidParameter: Invalid parameter, invalid memory alignment.     
02382         /// - AK_Fail: Load or unload failed for any other reason. (Most likely small allocation failure)
02383         /// \remarks
02384         /// Whenever at least one event fails to be resolved, the actions performed for all 
02385         /// other events are cancelled.
02386         /// \sa
02387         /// - <tt>AK::SoundEngine::PrepareEvent()</tt>
02388         /// - <tt>AK::SoundEngine::ClearPreparedEvents()</tt>
02389         /// - <tt>AK::SoundEngine::GetIDFromString()</tt>
02390         /// - <tt>AK::SoundEngine::LoadBank()</tt>
02391         /// - \ref soundengine_banks
02392         /// - \ref sdk_bank_training
02393         AK_EXTERNAPIFUNC( AKRESULT, PrepareEvent )( 
02394             PreparationType     in_PreparationType,     ///< Preparation type ( Preparation_Load or Preparation_Unload )
02395             const wchar_t**     in_ppszString,          ///< Array of event names
02396             AkUInt32            in_uNumEvent            ///< Number of events in the array
02397             );
02398 #endif //AK_SUPPORT_WCHAR
02399 
02400         /// Prepares or unprepares events synchronously.\n
02401         /// The Events are identified by strings and converted to IDs internally
02402         /// (refer to \ref soundengine_banks_general for a discussion on using strings and IDs).
02403         /// Before invoking PrepareEvent(), use LoadBank() to explicitly load the SoundBank(s) 
02404         /// that contain the Events and structures. When a request is posted to the
02405         /// Bank Manager consumer thread, it will resolve all dependencies needed to 
02406         /// successfully post the specified Events and load the required loose media files. 
02407         /// \aknote Before version 2015.1, the required media files could be included
02408         /// in a separate media SoundBank. As described in \ref whatsnew_2015_1_migration,
02409         /// however, PrepareEvent() now only looks for loose media files.
02410         /// \endaknote
02411         /// The function returns when the request is completely processed.
02412         /// \return 
02413         /// - AK_Success: Prepare/un-prepare successful.
02414         /// - AK_IDNotFound: At least one of the event/game sync identifiers passed to PrepareEvent() does not exist.
02415         /// - AK_InsufficientMemory: Insufficient memory to store bank data.
02416         /// - AK_BankReadError: I/O error.
02417         /// - AK_WrongBankVersion: Invalid bank version: make sure the version of Wwise that 
02418         /// you used to generate the SoundBanks matches that of the SDK you are currently using.
02419         /// - AK_InvalidFile: File specified could not be opened.
02420         /// - AK_InvalidParameter: Invalid parameter, invalid memory alignment.     
02421         /// - AK_Fail: Load or unload failed for any other reason. (Most likely small allocation failure)
02422         /// \remarks
02423         /// Whenever at least one event fails to be resolved, the actions performed for all 
02424         /// other events are cancelled.
02425         /// \sa
02426         /// - <tt>AK::SoundEngine::PrepareEvent()</tt>
02427         /// - <tt>AK::SoundEngine::ClearPreparedEvents()</tt>
02428         /// - <tt>AK::SoundEngine::GetIDFromString()</tt>
02429         /// - <tt>AK::SoundEngine::LoadBank()</tt>
02430         /// - \ref soundengine_banks
02431         /// - \ref sdk_bank_training
02432         AK_EXTERNAPIFUNC( AKRESULT, PrepareEvent )( 
02433             PreparationType     in_PreparationType,     ///< Preparation type ( Preparation_Load or Preparation_Unload )
02434             const char**        in_ppszString,          ///< Array of event names
02435             AkUInt32            in_uNumEvent            ///< Number of events in the array
02436             );
02437 
02438         /// Prepares or unprepares events synchronously (by ID).
02439         /// The Events are identified by their ID (refer to \ref soundengine_banks_general for a discussion on using strings and IDs).
02440         /// Before invoking PrepareEvent(), use LoadBank() to explicitly load the SoundBank(s) 
02441         /// that contain the Events and structures. When a request is posted to the
02442         /// Bank Manager consumer thread, it will resolve all dependencies needed to 
02443         /// successfully post the specified Events and load the required loose media files. 
02444         /// \aknote Before version 2015.1, the required media files could be included
02445         /// in a separate media SoundBank. As described in \ref whatsnew_2015_1_migration,
02446         /// however, PrepareEvent() now only looks for loose media files.
02447         /// \endaknote
02448         /// The function returns when the request is completely processed.
02449         /// \return 
02450         /// - AK_Success: Prepare/un-prepare successful.
02451         /// - AK_IDNotFound: At least one of the event/game sync identifiers passed to PrepareEvent() does not exist.
02452         /// - AK_InsufficientMemory: Insufficient memory to store bank data.
02453         /// - AK_BankReadError: I/O error.
02454         /// - AK_WrongBankVersion: Invalid bank version: make sure the version of Wwise that 
02455         /// you used to generate the SoundBanks matches that of the SDK you are currently using.
02456         /// - AK_InvalidFile: File specified could not be opened.
02457         /// - AK_InvalidParameter: Invalid parameter, invalid memory alignment.     
02458         /// - AK_Fail: Load or unload failed for any other reason. (Most likely small allocation failure)
02459         /// \remarks
02460         /// Whenever at least one event fails to be resolved, the actions performed for all 
02461         /// other events are cancelled.
02462         /// \sa
02463         /// - <tt>AK::SoundEngine::PrepareEvent()</tt>
02464         /// - <tt>AK::SoundEngine::ClearPreparedEvents()</tt>
02465         /// - <tt>AK::SoundEngine::GetIDFromString()</tt>
02466         /// - <tt>AK::SoundEngine::LoadBank()</tt>
02467         /// - \ref soundengine_banks
02468         /// - \ref sdk_bank_training
02469         AK_EXTERNAPIFUNC( AKRESULT, PrepareEvent )( 
02470             PreparationType     in_PreparationType,     ///< Preparation type ( Preparation_Load or Preparation_Unload )
02471             AkUniqueID*         in_pEventID,            ///< Array of event IDs
02472             AkUInt32            in_uNumEvent            ///< Number of event IDs in the array
02473             );
02474 
02475 #ifdef AK_SUPPORT_WCHAR
02476         /// Prepares or unprepares an event asynchronously (by Unicode string).
02477         /// The Events are identified by string (refer to \ref soundengine_banks_general for a discussion on using strings and IDs).
02478         /// Before invoking PrepareEvent(), use LoadBank() to explicitly load the SoundBank(s) 
02479         /// that contain the Events and structures. When a request is posted to the
02480         /// Bank Manager consumer thread, it will resolve all dependencies needed to 
02481         /// successfully post the specified Events and load the required loose media files. 
02482         /// \aknote Before version 2015.1, the required media files could be included
02483         /// in a separate media SoundBank. As described in \ref whatsnew_2015_1_migration,
02484         /// however, \c PrepareEvent() now only looks for loose media files.
02485         /// \endaknote
02486         /// The function returns immediately. Use a callback to be notified when the request has finished being processed.
02487         /// \return AK_Success if scheduling is was successful, AK_Fail otherwise.
02488         /// \remarks
02489         /// Whenever at least one Event fails to be resolved, the actions performed for all 
02490         /// other Events are cancelled.
02491         /// \sa
02492         /// - <tt>AK::SoundEngine::PrepareEvent()</tt>
02493         /// - <tt>AK::SoundEngine::ClearPreparedEvents()</tt>
02494         /// - <tt>AK::SoundEngine::GetIDFromString()</tt>
02495         /// - <tt>AK::SoundEngine::LoadBank()</tt>
02496         /// - AkBankCallbackFunc
02497         /// - \ref soundengine_banks
02498         /// - \ref sdk_bank_training
02499         AK_EXTERNAPIFUNC( AKRESULT, PrepareEvent )( 
02500             PreparationType     in_PreparationType,     ///< Preparation type ( Preparation_Load or Preparation_Unload )
02501             const wchar_t**     in_ppszString,          ///< Array of event names
02502             AkUInt32            in_uNumEvent,           ///< Number of events in the array
02503             AkBankCallbackFunc  in_pfnBankCallback,     ///< Callback function
02504             void *              in_pCookie              ///< Callback cookie (reserved to user, passed to the callback function)
02505             );
02506 #endif //AK_SUPPORT_WCHAR
02507 
02508         /// Prepares or unprepares an event asynchronously.
02509         /// The Events are identified by string (refer to \ref soundengine_banks_general for a discussion on using strings and IDs).
02510         /// Before invoking PrepareEvent(), use LoadBank() to explicitly load the SoundBank(s) 
02511         /// that contain the Events and structures. When a request is posted to the
02512         /// Bank Manager consumer thread, it will resolve all dependencies needed to 
02513         /// successfully post the specified Events and load the required loose media files. 
02514         /// \aknote Before version 2015.1, the required media files could be included
02515         /// in a separate media SoundBank. As described in \ref whatsnew_2015_1_migration,
02516         /// however, PrepareEvent() now only looks for loose media files.
02517         /// \endaknote
02518         /// The function returns immediately. Use a callback to be notified when the request has finished being processed.
02519         /// \return AK_Success if scheduling is was successful, AK_Fail otherwise.
02520         /// \remarks
02521         /// Whenever at least one event fails to be resolved, the actions performed for all 
02522         /// other events are cancelled.
02523         /// \sa
02524         /// - <tt>AK::SoundEngine::PrepareEvent()</tt>
02525         /// - <tt>AK::SoundEngine::ClearPreparedEvents()</tt>
02526         /// - <tt>AK::SoundEngine::GetIDFromString()</tt>
02527         /// - <tt>AK::SoundEngine::LoadBank()</tt>
02528         /// - AkBankCallbackFunc
02529         /// - \ref soundengine_banks
02530         /// - \ref sdk_bank_training
02531         AK_EXTERNAPIFUNC( AKRESULT, PrepareEvent )( 
02532             PreparationType     in_PreparationType,     ///< Preparation type ( Preparation_Load or Preparation_Unload )
02533             const char**        in_ppszString,          ///< Array of event names 
02534             AkUInt32            in_uNumEvent,           ///< Number of events in the array
02535             AkBankCallbackFunc  in_pfnBankCallback,     ///< Callback function
02536             void *              in_pCookie              ///< Callback cookie (reserved to user, passed to the callback function)
02537             );
02538 
02539         /// Prepares or unprepares events asynchronously (by ID).\n
02540         /// The Events are identified by their ID (refer to \ref soundengine_banks_general for a discussion on using strings and IDs).
02541         /// Before invoking PrepareEvent(), use LoadBank() to explicitly load the SoundBank(s) 
02542         /// that contain the Events and structures. When a request is posted to the
02543         /// Bank Manager consumer thread, it will resolve all dependencies needed to 
02544         /// successfully post the specified Events and load the required loose media files. 
02545         /// \aknote Before version 2015.1, the required media files could be included
02546         /// in a separate media SoundBank. As described in \ref whatsnew_2015_1_migration,
02547         /// however, PrepareEvent() now only looks for loose media files.
02548         /// \endaknote
02549         /// The function returns immediately. Use a callback to be notified when the request has finished being processed.
02550         /// \return AK_Success if scheduling is was successful, AK_Fail otherwise.
02551         /// \remarks
02552         /// Whenever at least one event fails to be resolved, the actions performed for all 
02553         /// other events are cancelled.
02554         /// \sa
02555         /// - <tt>AK::SoundEngine::PrepareEvent()</tt>
02556         /// - <tt>AK::SoundEngine::ClearPreparedEvents()</tt>
02557         /// - <tt>AK::SoundEngine::GetIDFromString()</tt>
02558         /// - <tt>AK::SoundEngine::LoadBank()</tt>
02559         /// - AkBankCallbackFunc
02560         /// - \ref soundengine_banks
02561         /// - \ref sdk_bank_training
02562         AK_EXTERNAPIFUNC( AKRESULT, PrepareEvent )( 
02563             PreparationType     in_PreparationType,     ///< Preparation type ( Preparation_Load or Preparation_Unload )
02564             AkUniqueID*         in_pEventID,            ///< Array of event IDs
02565             AkUInt32            in_uNumEvent,           ///< Number of event IDs in the array
02566             AkBankCallbackFunc  in_pfnBankCallback,     ///< Callback function
02567             void *              in_pCookie              ///< Callback cookie (reserved to user, passed to the callback function)
02568             );
02569 
02570         /// Indicates the location of a specific Media ID in memory
02571         /// The sources are identified by their ID (refer to \ref soundengine_banks_general for a discussion on using strings and IDs).
02572         /// \return AK_Success if operation was successful, AK_InvalidParameter if in_pSourceSettings is invalid, and AK_Fail otherwise.
02573         AK_EXTERNAPIFUNC( AKRESULT, SetMedia )( 
02574             AkSourceSettings *  in_pSourceSettings,     ///< Array of Source Settings
02575             AkUInt32            in_uNumSourceSettings   ///< Number of Source Settings in the array
02576             );
02577 
02578         /// Removes the specified source from the list of loaded media.
02579         /// The sources are identified by their ID (refer to \ref soundengine_banks_general for a discussion on using strings and IDs).
02580         /// \return AK_Success if operation was successful, AK_InvalidParameter if in_pSourceSettings is invalid, and AK_Fail otherwise.
02581         AK_EXTERNAPIFUNC( AKRESULT, UnsetMedia )( 
02582             AkSourceSettings *  in_pSourceSettings,     ///< Array of Source Settings
02583             AkUInt32            in_uNumSourceSettings   ///< Number of Source Settings in the array
02584             );
02585 
02586 #ifdef AK_SUPPORT_WCHAR
02587         /// Prepares or unprepares game syncs synchronously (by Unicode string).\n
02588         /// The group and game syncs are specified by string (refer to \ref soundengine_banks_general for a discussion on using strings and IDs).
02589         /// The game syncs definitions must already exist in the sound engine by having
02590         /// explicitly loaded the bank(s) that contain them (with LoadBank()).
02591         /// A request is posted to the Bank Manager consumer thread. It will resolve all 
02592         /// dependencies needed to successfully set this game sync group to one of the
02593         /// game sync values specified, and load the required banks, if applicable. 
02594         /// The function returns when the request has been completely processed. 
02595         /// \return 
02596         /// - AK_Success: Prepare/un-prepare successful.
02597         /// - AK_IDNotFound: At least one of the event/game sync identifiers passed to PrepareGameSyncs() does not exist.
02598         /// - AK_InsufficientMemory: Insufficient memory to store bank data.
02599         /// - AK_BankReadError: I/O error.
02600         /// - AK_WrongBankVersion: Invalid bank version: make sure the version of Wwise that 
02601         /// you used to generate the SoundBanks matches that of the SDK you are currently using.
02602         /// - AK_InvalidFile: File specified could not be opened.
02603         /// - AK_InvalidParameter: Invalid parameter, invalid memory alignment.     
02604         /// - AK_Fail: Load or unload failed for any other reason. (Most likely small allocation failure)
02605         /// \remarks
02606         /// You need to call PrepareGameSyncs() if the sound engine was initialized with AkInitSettings::bEnableGameSyncPreparation 
02607         /// set to true. When set to false, the sound engine automatically prepares all game syncs when preparing events,
02608         /// so you never need to call this function.
02609         /// \sa 
02610         /// - \c <tt>AK::SoundEngine::GetIDFromString()</tt>
02611         /// - \c <tt>AK::SoundEngine::PrepareEvent()</tt>
02612         /// - \c <tt>AK::SoundEngine::LoadBank()</tt>
02613         /// - \c AkInitSettings
02614         /// - \ref soundengine_banks
02615         /// - \ref sdk_bank_training
02616         AK_EXTERNAPIFUNC( AKRESULT, PrepareGameSyncs )(
02617             PreparationType in_PreparationType,         ///< Preparation type ( Preparation_Load or Preparation_Unload )
02618             AkGroupType     in_eGameSyncType,           ///< The type of game sync.
02619             const wchar_t*  in_pszGroupName,            ///< The State Group Name or the Switch Group Name.
02620             const wchar_t** in_ppszGameSyncName,        ///< The specific ID of the state to either support or not support.
02621             AkUInt32        in_uNumGameSyncs            ///< The number of game sync in the string array.
02622             );
02623 #endif //AK_SUPPORT_WCHAR
02624 
02625         /// Prepares or unprepares game syncs synchronously.\n
02626         /// The group and game syncs are specified by string (refer to \ref soundengine_banks_general for a discussion on using strings and IDs).
02627         /// The game syncs definitions must already exist in the sound engine by having
02628         /// explicitly loaded the bank(s) that contain them (with LoadBank()).
02629         /// A request is posted to the Bank Manager consumer thread. It will resolve all 
02630         /// dependencies needed to successfully set this game sync group to one of the
02631         /// game sync values specified, and load the required banks, if applicable. 
02632         /// The function returns when the request has been completely processed. 
02633         /// \return 
02634         /// - AK_Success: Prepare/un-prepare successful.
02635         /// - AK_IDNotFound: At least one of the event/game sync identifiers passed to PrepareGameSyncs() does not exist.
02636         /// - AK_InsufficientMemory: Insufficient memory to store bank data.
02637         /// - AK_BankReadError: I/O error.
02638         /// - AK_WrongBankVersion: Invalid bank version: make sure the version of Wwise that 
02639         /// you used to generate the SoundBanks matches that of the SDK you are currently using.
02640         /// - AK_InvalidFile: File specified could not be opened.
02641         /// - AK_InvalidParameter: Invalid parameter, invalid memory alignment.     
02642         /// - AK_Fail: Load or unload failed for any other reason. (Most likely small allocation failure)
02643         /// \remarks
02644         /// You need to call PrepareGameSyncs() if the sound engine was initialized with AkInitSettings::bEnableGameSyncPreparation 
02645         /// set to true. When set to false, the sound engine automatically prepares all game syncs when preparing events,
02646         /// so you never need to call this function.
02647         /// \sa 
02648         /// - <tt>AK::SoundEngine::GetIDFromString()</tt>
02649         /// - <tt>AK::SoundEngine::PrepareEvent()</tt>
02650         /// - <tt>AK::SoundEngine::LoadBank()</tt>
02651         /// - AkInitSettings
02652         /// - \ref soundengine_banks
02653         /// - \ref sdk_bank_training
02654         AK_EXTERNAPIFUNC( AKRESULT, PrepareGameSyncs )(
02655             PreparationType in_PreparationType,         ///< Preparation type ( Preparation_Load or Preparation_Unload )
02656             AkGroupType     in_eGameSyncType,           ///< The type of game sync.
02657             const char*     in_pszGroupName,            ///< The State Group Name or the Switch Group Name.
02658             const char**    in_ppszGameSyncName,        ///< The specific ID of the state to either support or not support.
02659             AkUInt32        in_uNumGameSyncs            ///< The number of game sync in the string array.
02660             );
02661 
02662         /// Prepares or unprepares game syncs synchronously (by ID).\n
02663         /// The group and game syncs are specified by ID (refer to \ref soundengine_banks_general for a discussion on using strings and IDs).
02664         /// The game syncs definitions must already exist in the sound engine by having
02665         /// explicitly loaded the bank(s) that contain them (with LoadBank()).
02666         /// A request is posted to the Bank Manager consumer thread. It will resolve all 
02667         /// dependencies needed to successfully set this game sync group to one of the
02668         /// game sync values specified, and load the required banks, if applicable. 
02669         /// The function returns when the request has been completely processed. 
02670         /// \return 
02671         /// - AK_Success: Prepare/un-prepare successful.
02672         /// - AK_IDNotFound: At least one of the event/game sync identifiers passed to PrepareGameSyncs() does not exist.
02673         /// - AK_InsufficientMemory: Insufficient memory to store bank data.
02674         /// - AK_BankReadError: I/O error.
02675         /// - AK_WrongBankVersion: Invalid bank version: make sure the version of Wwise that 
02676         /// you used to generate the SoundBanks matches that of the SDK you are currently using.
02677         /// - AK_InvalidFile: File specified could not be opened.
02678         /// - AK_InvalidParameter: Invalid parameter, invalid memory alignment.     
02679         /// - AK_Fail: Load or unload failed for any other reason. (Most likely small allocation failure)
02680         /// \remarks
02681         /// You need to call \c PrepareGameSyncs() if the sound engine was initialized with \c AkInitSettings::bEnableGameSyncPreparation 
02682         /// set to \c true. When set to \c false, the sound engine automatically prepares all game syncs when preparing Events,
02683         /// so you never need to call this function.
02684         /// \sa 
02685         /// - <tt>AK::SoundEngine::GetIDFromString()</tt>
02686         /// - <tt>AK::SoundEngine::PrepareEvent()</tt>
02687         /// - <tt>AK::SoundEngine::LoadBank()</tt>
02688         /// - AkInitSettings
02689         /// - \ref soundengine_banks
02690         /// - \ref sdk_bank_training
02691         AK_EXTERNAPIFUNC( AKRESULT, PrepareGameSyncs )(
02692             PreparationType in_PreparationType,         ///< Preparation type ( Preparation_Load or Preparation_Unload )
02693             AkGroupType     in_eGameSyncType,           ///< The type of game sync.
02694             AkUInt32        in_GroupID,                 ///< The State Group ID or the Switch Group ID.
02695             AkUInt32*       in_paGameSyncID,            ///< Array of ID of the game syncs to either support or not support.
02696             AkUInt32        in_uNumGameSyncs            ///< The number of game sync ID in the array.
02697             );
02698 
02699 #ifdef AK_SUPPORT_WCHAR
02700         /// Prepares or unprepares game syncs asynchronously (by Unicode string).\n
02701         /// The group and game syncs are specified by string (refer to \ref soundengine_banks_general for a discussion on using strings and IDs).
02702         /// The game syncs definitions must already exist in the sound engine by having
02703         /// explicitly loaded the bank(s) that contain them (with <tt>LoadBank()</tt>).
02704         /// A request is posted to the Bank Manager consumer thread. It will resolve all 
02705         /// dependencies needed to successfully set this game sync group to one of the
02706         /// game sync values specified, and load the required banks, if applicable. 
02707         /// The function returns immediately. Use a callback to be notified when the request has finished being processed.
02708         /// \return AK_Success if scheduling is was successful, AK_Fail otherwise.
02709         /// \remarks
02710         /// You need to call \c PrepareGameSyncs() if the sound engine was initialized with \c AkInitSettings::bEnableGameSyncPreparation 
02711         /// set to \c true. When set to \c false, the sound engine automatically prepares all game syncs when preparing Events,
02712         /// so you never need to call this function.
02713         /// \sa 
02714         /// - \c <tt>AK::SoundEngine::GetIDFromString()</tt>
02715         /// - \c <tt>AK::SoundEngine::PrepareEvent()</tt>
02716         /// - \c <tt>AK::SoundEngine::LoadBank()</tt>
02717         /// - \c AkInitSettings
02718         /// - \c AkBankCallbackFunc
02719         /// - \ref soundengine_banks
02720         /// - \ref sdk_bank_training
02721         AK_EXTERNAPIFUNC( AKRESULT, PrepareGameSyncs )(
02722             PreparationType     in_PreparationType,     ///< Preparation type ( Preparation_Load or Preparation_Unload )
02723             AkGroupType         in_eGameSyncType,       ///< The type of game sync.
02724             const wchar_t*      in_pszGroupName,        ///< The State Group Name or the Switch Group Name.
02725             const wchar_t**     in_ppszGameSyncName,    ///< The specific ID of the state to either support or not support.
02726             AkUInt32            in_uNumGameSyncs,       ///< The number of game sync in the string array.
02727             AkBankCallbackFunc  in_pfnBankCallback,     ///< Callback function
02728             void *              in_pCookie              ///< Callback cookie (reserved to user, passed to the callback function)
02729             );
02730 #endif //AK_SUPPORT_WCHAR
02731 
02732         /// Prepares or unprepares game syncs asynchronously.\n
02733         /// The group and game syncs are specified by string (refer to \ref soundengine_banks_general for a discussion on using strings and IDs).
02734         /// The game syncs definitions must already exist in the sound engine by having
02735         /// explicitly loaded the bank(s) that contain them (with LoadBank()).
02736         /// A request is posted to the Bank Manager consumer thread. It will resolve all 
02737         /// dependencies needed to successfully set this game sync group to one of the
02738         /// game sync values specified, and load the required banks, if applicable. 
02739         /// The function returns immediately. Use a callback to be notified when the request has finished being processed.
02740         /// \return AK_Success if scheduling is was successful, AK_Fail otherwise.
02741         /// \remarks
02742         /// You need to call PrepareGameSyncs() if the sound engine was initialized with AkInitSettings::bEnableGameSyncPreparation 
02743         /// set to true. When set to false, the sound engine automatically prepares all game syncs when preparing events,
02744         /// so you never need to call this function.
02745         /// \sa 
02746         /// - <tt>AK::SoundEngine::GetIDFromString()</tt>
02747         /// - <tt>AK::SoundEngine::PrepareEvent()</tt>
02748         /// - <tt>AK::SoundEngine::LoadBank()</tt>
02749         /// - AkInitSettings
02750         /// - AkBankCallbackFunc
02751         /// - \ref soundengine_banks
02752         /// - \ref sdk_bank_training
02753         AK_EXTERNAPIFUNC( AKRESULT, PrepareGameSyncs )(
02754             PreparationType     in_PreparationType,     ///< Preparation type ( Preparation_Load or Preparation_Unload )
02755             AkGroupType         in_eGameSyncType,       ///< The type of game sync.
02756             const char*         in_pszGroupName,        ///< The State Group Name or the Switch Group Name.
02757             const char**        in_ppszGameSyncName,    ///< The specific ID of the state to either support or not support.
02758             AkUInt32            in_uNumGameSyncs,       ///< The number of game sync in the string array.
02759             AkBankCallbackFunc  in_pfnBankCallback,     ///< Callback function
02760             void *              in_pCookie              ///< Callback cookie (reserved to user, passed to the callback function)
02761             );
02762 
02763         /// Prepares or un-prepare game syncs asynchronously (by ID).\n
02764         /// The group and game syncs are specified by ID (refer to \ref soundengine_banks_general for a discussion on using strings and IDs).
02765         /// The game syncs definitions must already exist in the sound engine by having
02766         /// explicitly loaded the bank(s) that contain them (with LoadBank()).
02767         /// A request is posted to the Bank Manager consumer thread. It will resolve all 
02768         /// dependencies needed to successfully set this game sync group to one of the
02769         /// game sync values specified, and load the required banks, if applicable. 
02770         /// The function returns immediately. Use a callback to be notified when the request has finished being processed.
02771         /// \return AK_Success if scheduling is was successful, AK_Fail otherwise.
02772         /// \remarks
02773         /// You need to call PrepareGameSyncs() if the sound engine was initialized with AkInitSettings::bEnableGameSyncPreparation 
02774         /// set to true. When set to false, the sound engine automatically prepares all Game Syncs when preparing Events,
02775         /// so you never need to call this function.
02776         /// \sa 
02777         /// - <tt>AK::SoundEngine::GetIDFromString()</tt>
02778         /// - <tt>AK::SoundEngine::PrepareEvent()</tt>
02779         /// - <tt>AK::SoundEngine::LoadBank()</tt>
02780         /// - AkInitSettings
02781         /// - AkBankCallbackFunc
02782         /// - \ref soundengine_banks
02783         /// - \ref sdk_bank_training
02784         AK_EXTERNAPIFUNC( AKRESULT, PrepareGameSyncs )(
02785             PreparationType     in_PreparationType,     ///< Preparation type ( Preparation_Load or Preparation_Unload )
02786             AkGroupType         in_eGameSyncType,       ///< The type of game sync.
02787             AkUInt32            in_GroupID,             ///< The State Group ID or the Switch Group ID.
02788             AkUInt32*           in_paGameSyncID,        ///< Array of ID of the Game Syncs to either support or not support.
02789             AkUInt32            in_uNumGameSyncs,       ///< The number of game sync ID in the array.
02790             AkBankCallbackFunc  in_pfnBankCallback,     ///< Callback function
02791             void *              in_pCookie              ///< Callback cookie (reserved to user, passed to the callback function)
02792             );
02793 
02794         //@}
02795 
02796 
02797         ////////////////////////////////////////////////////////////////////////
02798         /// @name Listeners
02799         //@{
02800 
02801         /// Sets a game object's associated listeners.
02802         /// All listeners that have previously been added via AddListener or set via SetListeners will be removed and replaced with the listeners in the array in_pListenerGameObjs.
02803         /// Calling this function will override the default set of listeners and in_emitterGameObj will now reference its own, unique set of listeners.
02804         /// \return Always returns AK_Success
02805         /// \sa 
02806         /// - <tt>AK::SoundEngine::AddListener</tt>
02807         /// - <tt>AK::SoundEngine::RemoveListener</tt>
02808         /// - <tt>AK::SoundEngine::SetDefaultListeners</tt>
02809         /// - \ref soundengine_listeners
02810         AK_EXTERNAPIFUNC( AKRESULT, SetListeners )(
02811             AkGameObjectID in_emitterGameObj,           ///< Emitter game object.  Must have been previously registered via RegisterGameObj.
02812             const AkGameObjectID* in_pListenerGameObjs, ///< Array of listener game object IDs that will be activated for in_emitterGameObj. 
02813             AkUInt32 in_uNumListeners                   ///< Length of array
02814             );
02815 
02816         /// Add a single listener to a game object's set of associated listeners.
02817         /// Any listeners that have previously been added or set via AddListener or SetListeners will remain as listeners and in_listenerGameObj will be added as an additional listener.
02818         /// Calling this function will override the default set of listeners and in_emitterGameObj will now reference its own, unique set of listeners.
02819         /// \sa 
02820         /// - <tt>AK::SoundEngine::SetListeners</tt>
02821         /// - <tt>AK::SoundEngine::RemoveListener</tt>
02822         /// - <tt>AK::SoundEngine::SetDefaultListeners</tt>
02823         /// - \ref soundengine_listeners
02824         AK_EXTERNAPIFUNC(AKRESULT, AddListener)(
02825             AkGameObjectID in_emitterGameObj,           ///< Emitter game object.  Must have been previously registered via RegisterGameObj.
02826             AkGameObjectID in_listenerGameObj           ///< Listener game object IDs that will be activated for in_emitterGameObj. 
02827             );
02828 
02829         /// Remove a single listener from a game object's set of active listeners.
02830         /// Calling this function will override the default set of listeners and in_emitterGameObj will now reference its own, unique set of listeners.
02831         /// \sa 
02832         /// - <tt>AK::SoundEngine::SetListeners</tt>
02833         /// - <tt>AK::SoundEngine::AddListener</tt>
02834         /// - <tt>AK::SoundEngine::SetDefaultListeners</tt>
02835         /// - \ref soundengine_listeners
02836         AK_EXTERNAPIFUNC(AKRESULT, RemoveListener)(
02837             AkGameObjectID in_emitterGameObj,           ///< Emitter game object.
02838             AkGameObjectID in_listenerGameObj           ///< Listener game object IDs that will be deactivated for in_emitterGameObj. Game objects must have been previously registered.
02839             );
02840 
02841         /// Sets the default set of associated listeners for game objects that have not explicitly overridden their listener sets.  Upon registration, all game objects reference the default listener set, until
02842         /// a call to AddListener, RemoveListener, SetListeners or SetGameObjectOutputBusVolume is made on that game object.
02843         /// All default listeners that have previously been added via AddDefaultListener or set via SetDefaultListeners will be removed and replaced with the listeners in the array in_pListenerGameObjs.
02844         /// \return Always returns AK_Success
02845         /// \sa 
02846         /// - \ref soundengine_listeners
02847         AK_EXTERNAPIFUNC(AKRESULT, SetDefaultListeners)(
02848             const AkGameObjectID* in_pListenerObjs, ///< Array of listener game object IDs that will be activated for subsequent registrations. Game objects must have been previously registered.
02849             AkUInt32 in_uNumListeners               ///< Length of array
02850             );
02851 
02852         /// Add a single listener to the default set of listeners.  Upon registration, all game objects reference the default listener set, until
02853         /// a call to AddListener, RemoveListener, SetListeners or SetGameObjectOutputBusVolume is made on that game object.
02854         /// \sa 
02855         /// - <tt>AK::SoundEngine::SetDefaultListeners</tt>
02856         /// - <tt>AK::SoundEngine::RemoveDefaultListener</tt>
02857         /// - \ref soundengine_listeners
02858         AK_EXTERNAPIFUNC(AKRESULT, AddDefaultListener)(
02859             AkGameObjectID in_listenerGameObj           ///< Listener game object IDs that will be added to the default set of listeners.
02860             );
02861 
02862         /// Remove a single listener from the default set of listeners.  Upon registration, all game objects reference the default listener set, until
02863         /// a call to AddListener, RemoveListener, SetListeners or SetGameObjectOutputBusVolume is made on that game object.
02864         /// \sa 
02865         /// - <tt>AK::SoundEngine::SetDefaultListeners</tt>
02866         /// - <tt>AK::SoundEngine::AddDefaultListener</tt>
02867         /// - \ref soundengine_listeners
02868         AK_EXTERNAPIFUNC(AKRESULT, RemoveDefaultListener)(
02869             AkGameObjectID in_listenerGameObj           ///< Listener game object IDs that will be removed from the default set of listeners.
02870             );
02871 
02872         /// Resets the listener associations to the default listener(s), as set by <tt>SetDefaultListeners</tt>. This will also reset per-listener gains that have been set using <tt>SetGameObjectOutputBusVolume</tt>.
02873         /// \return Always returns AK_Success
02874         /// \sa 
02875         /// - <tt>AK::SoundEngine::SetListeners</tt>
02876         /// - <tt>AK::SoundEngine::SetDefaultListeners</tt>
02877         /// - <tt>AK::SoundEngine::SetGameObjectOutputBusVolume</tt>
02878         /// - \ref soundengine_listeners
02879         AK_EXTERNAPIFUNC(AKRESULT, ResetListenersToDefault)(
02880             AkGameObjectID in_emitterGameObj    ///< Emitter game object.
02881             );
02882 
02883         /// Sets a listener's spatialization parameters. This let you define listener-specific 
02884         /// volume offsets for each audio channel.
02885         /// If \c in_bSpatialized is false, only \c in_pVolumeOffsets is used for this listener (3D positions 
02886         /// have no effect on the speaker distribution). Otherwise, \c in_pVolumeOffsets is added to the speaker
02887         /// distribution computed for this listener.
02888         /// Use helper functions of \c AK::SpeakerVolumes to manipulate the vector of volume offsets in_pVolumeOffsets.
02889         /// 
02890         /// If a sound is mixed into a bus that has a different speaker configuration than in_channelConfig,
02891         /// standard up/downmix rules apply.
02892         /// \return \c AK_Success if message was successfully posted to sound engine queue, \c AK_Fail otherwise.
02893         /// \sa 
02894         /// - \ref soundengine_listeners_spatial
02895         AK_EXTERNAPIFUNC( AKRESULT, SetListenerSpatialization )(
02896             AkGameObjectID in_uListenerID,              ///< Listener game object ID
02897             bool in_bSpatialized,                       ///< Spatialization toggle (True : enable spatialization, False : disable spatialization)
02898             AkChannelConfig in_channelConfig,           ///< Channel configuration associated with volumes in_pVolumeOffsets. Ignored if in_pVolumeOffsets is NULL.
02899             AK::SpeakerVolumes::VectorPtr in_pVolumeOffsets = NULL  ///< Per-speaker volume offset, in dB. See AkSpeakerVolumes.h for how to manipulate this vector.
02900             );
02901 
02902         //@}
02903 
02904 
02905         ////////////////////////////////////////////////////////////////////////
02906         /// @name Game Syncs
02907         //@{
02908 
02909         /// Sets the value of a real-time parameter control (by ID).
02910         /// With this function, you may set a game parameter value with global scope or with game object scope. 
02911         /// Game object scope supersedes global scope. (Once a value is set for the game object scope, it will not be affected by changes to the global scope value.) Game parameter values set with a global scope are applied to all 
02912         /// game objects that not yet registered, or already registered but not overridden with a value with game object scope.
02913         /// To set a game parameter value with global scope, pass \c AK_INVALID_GAME_OBJECT as the game object. 
02914         /// With this function, you may also change the value of a game parameter over time. To do so, specify a non-zero 
02915         /// value for \c in_uValueChangeDuration. At each audio frame, the game parameter value will be updated internally 
02916         /// according to the interpolation curve. If you call \c <tt><tt>SetRTPCValue()</tt></tt> with <tt>in_uValueChangeDuration = 0</tt> in the 
02917         /// middle of an interpolation, the interpolation stops and the new value is set directly. Thus, if you call this 
02918         /// function at every game frame, you should not use \c in_uValueChangeDuration, as it would have no effect and it is less efficient.
02919         /// Refer to \ref soundengine_rtpc_pergameobject, \ref soundengine_rtpc_buses and 
02920         /// \ref soundengine_rtpc_effects for more details on RTPC scope.
02921         /// \return Always \c AK_Success
02922         /// \sa 
02923         /// - \ref soundengine_rtpc
02924         /// - <tt>AK::SoundEngine::GetIDFromString()</tt>
02925         AK_EXTERNAPIFUNC( AKRESULT, SetRTPCValue )( 
02926             AkRtpcID in_rtpcID,                                     ///< ID of the game parameter
02927             AkRtpcValue in_value,                                   ///< Value to set
02928             AkGameObjectID in_gameObjectID = AK_INVALID_GAME_OBJECT,///< Associated game object ID
02929             AkTimeMs in_uValueChangeDuration = 0,                   ///< Duration during which the game parameter is interpolated towards in_value
02930             AkCurveInterpolation in_eFadeCurve = AkCurveInterpolation_Linear,   ///< Curve type to be used for the game parameter interpolation
02931             bool in_bBypassInternalValueInterpolation = false       ///< True if you want to bypass the internal "slew rate" or "over time filtering" specified by the sound designer. This is meant to be used when for example loading a level and you dont want the values to interpolate.
02932             );
02933 
02934 #ifdef AK_SUPPORT_WCHAR
02935         /// Sets the value of a real-time parameter control (by Unicode string name).
02936         /// With this function, you may set a game parameter value to global scope or to game object scope. 
02937         /// Game object scope supersedes global scope. (Once a value is set for the game object scope, it will not be affected by changes to the global scope value.) Game parameter values set with global scope are applied to all 
02938         /// game objects that not yet registered, or already registered but not overridden with a value with game object scope.
02939         /// To set a game parameter value with global scope, pass AK_INVALID_GAME_OBJECT as the game object. 
02940         /// With this function, you may also change the value of a game parameter over time. To do so, specify a non-zero 
02941         /// value for in_uValueChangeDuration. At each audio frame, the game parameter value will be updated internally 
02942         /// according to the interpolation curve. If you call SetRTPCValue() with in_uValueChangeDuration = 0 in the 
02943         /// middle of an interpolation, the interpolation stops and the new value is set directly. Thus, if you call this 
02944         /// function at every game frame, you should not use in_uValueChangeDuration, as it would have no effect and it is less efficient.
02945         /// Refer to \ref soundengine_rtpc_pergameobject, \ref soundengine_rtpc_buses and 
02946         /// \ref soundengine_rtpc_effects for more details on RTPC scope.
02947         /// \return 
02948         /// - AK_Success if successful
02949         /// - AK_IDNotFound if in_pszRtpcName is NULL.
02950         /// \aknote Strings are case-insensitive. \endaknote
02951         /// \sa 
02952         /// - \ref soundengine_rtpc
02953         AK_EXTERNAPIFUNC( AKRESULT, SetRTPCValue )( 
02954             const wchar_t* in_pszRtpcName,                          ///< Name of the game parameter
02955             AkRtpcValue in_value,                                   ///< Value to set
02956             AkGameObjectID in_gameObjectID = AK_INVALID_GAME_OBJECT,///< Associated game object ID
02957             AkTimeMs in_uValueChangeDuration = 0,                   ///< Duration during which the game parameter is interpolated towards in_value
02958             AkCurveInterpolation in_eFadeCurve = AkCurveInterpolation_Linear,   ///< Curve type to be used for the game parameter interpolation
02959             bool in_bBypassInternalValueInterpolation = false       ///< True if you want to bypass the internal "slew rate" or "over time filtering" specified by the sound designer. This is meant to be used when for example loading a level and you dont want the values to interpolate.
02960             );
02961 #endif //AK_SUPPORT_WCHAR
02962 
02963         /// Sets the value of a real-time parameter control.
02964         /// With this function, you may set a game parameter value with global scope or with game object scope. 
02965         /// Game object scope supersedes global scope. (Once a value is set for the game object scope, it will not be affected by changes to the global scope value.) Game parameter values set with global scope are applied to all 
02966         /// game objects that not yet registered, or already registered but not overridden with a value with game object scope.
02967         /// To set a game parameter value with global scope, pass AK_INVALID_GAME_OBJECT as the game object. 
02968         /// With this function, you may also change the value of a game parameter over time. To do so, specify a non-zero 
02969         /// value for \c in_uValueChangeDuration. At each audio frame, the game parameter value will be updated internally 
02970         /// according to the interpolation curve. If you call SetRTPCValue() with in_uValueChangeDuration = 0 in the 
02971         /// middle of an interpolation, the interpolation stops and the new value is set directly. Thus, if you call this 
02972         /// function at every game frame, you should not use in_uValueChangeDuration, as it would have no effect and it is less efficient.
02973         /// Refer to \ref soundengine_rtpc_pergameobject, \ref soundengine_rtpc_buses and 
02974         /// \ref soundengine_rtpc_effects for more details on RTPC scope.
02975         /// \return 
02976         /// - AK_Success if successful
02977         /// - AK_IDNotFound if in_pszRtpcName is NULL.
02978         /// \aknote Strings are case-insensitive. \endaknote
02979         /// \sa 
02980         /// - \ref soundengine_rtpc
02981         AK_EXTERNAPIFUNC( AKRESULT, SetRTPCValue )( 
02982             const char* in_pszRtpcName,                             ///< Name of the game parameter
02983             AkRtpcValue in_value,                                   ///< Value to set
02984             AkGameObjectID in_gameObjectID = AK_INVALID_GAME_OBJECT,///< Associated game object ID
02985             AkTimeMs in_uValueChangeDuration = 0,                   ///< Duration during which the game parameter is interpolated towards in_value
02986             AkCurveInterpolation in_eFadeCurve = AkCurveInterpolation_Linear,   ///< Curve type to be used for the game parameter interpolation
02987             bool in_bBypassInternalValueInterpolation = false       ///< True if you want to bypass the internal "slew rate" or "over time filtering" specified by the sound designer. This is meant to be used when for example loading a level and you dont want the values to interpolate.
02988             );
02989 
02990         /// Sets the value of a real-time parameter control (by ID).
02991         /// With this function, you may set a game parameter value on playing id scope. 
02992         /// Playing id scope supersedes both game object scope and global scope. 
02993         /// With this function, you may also change the value of a game parameter over time. To do so, specify a non-zero 
02994         /// value for in_uValueChangeDuration. At each audio frame, the game parameter value will be updated internally 
02995         /// according to the interpolation curve. If you call SetRTPCValueByPlayingID() with in_uValueChangeDuration = 0 in the 
02996         /// middle of an interpolation, the interpolation stops and the new value is set directly. Thus, if you call this 
02997         /// function at every game frame, you should not use in_uValueChangeDuration, as it would have no effect and it is less efficient.
02998         /// Refer to \ref soundengine_rtpc_pergameobject, \ref soundengine_rtpc_buses and 
02999         /// \ref soundengine_rtpc_effects for more details on RTPC scope.
03000         /// \return Always AK_Success
03001         /// \sa 
03002         /// - \ref soundengine_rtpc
03003         /// - <tt>AK::SoundEngine::GetIDFromString()</tt>
03004         AK_EXTERNAPIFUNC( AKRESULT, SetRTPCValueByPlayingID )( 
03005             AkRtpcID in_rtpcID,                                     ///< ID of the game parameter
03006             AkRtpcValue in_value,                                   ///< Value to set
03007             AkPlayingID in_playingID,                               ///< Associated playing ID
03008             AkTimeMs in_uValueChangeDuration = 0,                   ///< Duration during which the game parameter is interpolated towards in_value
03009             AkCurveInterpolation in_eFadeCurve = AkCurveInterpolation_Linear,   ///< Curve type to be used for the game parameter interpolation
03010             bool in_bBypassInternalValueInterpolation = false       ///< True if you want to bypass the internal "slew rate" or "over time filtering" specified by the sound designer. This is meant to be used when, for example, loading a level and you don't want the values to interpolate.
03011             );
03012 
03013 #ifdef AK_SUPPORT_WCHAR
03014         /// Sets the value of a real-time parameter control (by Unicode string name).
03015         /// With this function, you may set a game parameter value on playing ID scope. 
03016         /// Playing id scope supersedes both game object scope and global scope. 
03017         /// With this function, you may also change the value of a game parameter over time. To do so, specify a non-zero 
03018         /// value for in_uValueChangeDuration. At each audio frame, the game parameter value will be updated internally 
03019         /// according to the interpolation curve. If you call SetRTPCValueByPlayingID() with in_uValueChangeDuration = 0 in the 
03020         /// middle of an interpolation, the interpolation stops and the new value is set directly. Thus, if you call this 
03021         /// function at every game frame, you should not use in_uValueChangeDuration, as it would have no effect and it is less efficient.
03022         /// Refer to \ref soundengine_rtpc_pergameobject, \ref soundengine_rtpc_buses and 
03023         /// \ref soundengine_rtpc_effects for more details on RTPC scope.
03024         /// \return Always AK_Success
03025         /// \sa 
03026         /// - \ref soundengine_rtpc
03027         /// - <tt>AK::SoundEngine::GetIDFromString()</tt>
03028         AK_EXTERNAPIFUNC( AKRESULT, SetRTPCValueByPlayingID )( 
03029             const wchar_t* in_pszRtpcName,                          ///< Name of the game parameter
03030             AkRtpcValue in_value,                                   ///< Value to set
03031             AkPlayingID in_playingID,                               ///< Associated playing ID
03032             AkTimeMs in_uValueChangeDuration = 0,                   ///< Duration during which the game parameter is interpolated towards in_value
03033             AkCurveInterpolation in_eFadeCurve = AkCurveInterpolation_Linear,   ///< Curve type to be used for the game parameter interpolation
03034             bool in_bBypassInternalValueInterpolation = false       ///< True if you want to bypass the internal "slew rate" or "over time filtering" specified by the sound designer. This is meant to be used when, for example, loading a level and you don't want the values to interpolate.
03035             );
03036 #endif //AK_SUPPORT_WCHAR
03037         
03038         /// Sets the value of a real-time parameter control (by string name).
03039         /// With this function, you may set a game parameter value on playing id scope. 
03040         /// Playing id scope supersedes both game object scope and global scope. 
03041         /// With this function, you may also change the value of a game parameter over time. To do so, specify a non-zero 
03042         /// value for in_uValueChangeDuration. At each audio frame, the game parameter value will be updated internally 
03043         /// according to the interpolation curve. If you call SetRTPCValueByPlayingID() with in_uValueChangeDuration = 0 in the 
03044         /// middle of an interpolation, the interpolation stops and the new value is set directly. Thus, if you call this 
03045         /// function at every game frame, you should not use in_uValueChangeDuration, as it would have no effect and it is less efficient.
03046         /// Refer to \ref soundengine_rtpc_pergameobject, \ref soundengine_rtpc_buses and 
03047         /// \ref soundengine_rtpc_effects for more details on RTPC scope.
03048         /// \return Always AK_Success
03049         /// \sa 
03050         /// - \ref soundengine_rtpc
03051         /// - <tt>AK::SoundEngine::GetIDFromString()</tt>
03052         AK_EXTERNAPIFUNC( AKRESULT, SetRTPCValueByPlayingID )( 
03053             const char* in_pszRtpcName,                             ///< Name of the game parameter
03054             AkRtpcValue in_value,                                   ///< Value to set
03055             AkPlayingID in_playingID,                               ///< Associated playing ID
03056             AkTimeMs in_uValueChangeDuration = 0,                   ///< Duration during which the game parameter is interpolated towards in_value
03057             AkCurveInterpolation in_eFadeCurve = AkCurveInterpolation_Linear,   ///< Curve type to be used for the game parameter interpolation
03058             bool in_bBypassInternalValueInterpolation = false       ///< True if you want to bypass the internal "slew rate" or "over time filtering" specified by the sound designer. This is meant to be used when for example loading a level and you dont want the values to interpolate.
03059             );
03060 
03061         /// Resets the value of the game parameter to its default value, as specified in the Wwise project.
03062         /// With this function, you may reset a game parameter to its default value with global scope or with game object scope. 
03063         /// Game object scope supersedes global scope. Game parameter values reset with global scope are applied to all 
03064         /// game objects that were not overridden with a value with game object scope.
03065         /// To reset a game parameter value with global scope, pass AK_INVALID_GAME_OBJECT as the game object. 
03066         /// With this function, you may also reset the value of a game parameter over time. To do so, specify a non-zero 
03067         /// value for in_uValueChangeDuration. At each audio frame, the game parameter value will be updated internally 
03068         /// according to the interpolation curve. If you call SetRTPCValue() or ResetRTPCValue() with in_uValueChangeDuration = 0 in the 
03069         /// middle of an interpolation, the interpolation stops and the new value is set directly. 
03070         /// Refer to \ref soundengine_rtpc_pergameobject, \ref soundengine_rtpc_buses and 
03071         /// \ref soundengine_rtpc_effects for more details on RTPC scope.
03072         /// \return Always AK_Success
03073         /// \sa 
03074         /// - \ref soundengine_rtpc
03075         /// - <tt>AK::SoundEngine::GetIDFromString()</tt>
03076         /// - <tt>AK::SoundEngine::SetRTPCValue()</tt>
03077         AK_EXTERNAPIFUNC( AKRESULT, ResetRTPCValue )(
03078             AkRtpcID in_rtpcID,                                     ///< ID of the game parameter
03079             AkGameObjectID in_gameObjectID = AK_INVALID_GAME_OBJECT,///< Associated game object ID
03080             AkTimeMs in_uValueChangeDuration = 0,                   ///< Duration during which the game parameter is interpolated towards its default value
03081             AkCurveInterpolation in_eFadeCurve = AkCurveInterpolation_Linear,   ///< Curve type to be used for the game parameter interpolation
03082             bool in_bBypassInternalValueInterpolation = false       ///< True if you want to bypass the internal "slew rate" or "over time filtering" specified by the sound designer. This is meant to be used when for example loading a level and you dont want the values to interpolate.
03083             );
03084 
03085 #ifdef AK_SUPPORT_WCHAR
03086         /// Resets the value of the game parameter to its default value, as specified in the Wwise project.
03087         /// With this function, you may reset a game parameter to its default value with global scope or with game object scope. 
03088         /// Game object scope supersedes global scope. Game parameter values reset with global scope are applied to all 
03089         /// game objects that were not overridden with a value with game object scope.
03090         /// To reset a game parameter value with global scope, pass AK_INVALID_GAME_OBJECT as the game object. 
03091         /// With this function, you may also reset the value of a game parameter over time. To do so, specify a non-zero 
03092         /// value for in_uValueChangeDuration. At each audio frame, the game parameter value will be updated internally 
03093         /// according to the interpolation curve. If you call SetRTPCValue() or ResetRTPCValue() with in_uValueChangeDuration = 0 in the 
03094         /// middle of an interpolation, the interpolation stops and the new value is set directly. 
03095         /// Refer to \ref soundengine_rtpc_pergameobject, \ref soundengine_rtpc_buses and 
03096         /// \ref soundengine_rtpc_effects for more details on RTPC scope.
03097         /// \return 
03098         /// - AK_Success if successful
03099         /// - AK_IDNotFound if in_pszParamName is NULL.
03100         /// \aknote Strings are case-insensitive. \endaknote
03101         /// \sa 
03102         /// - \ref soundengine_rtpc
03103         /// - <tt>AK::SoundEngine::SetRTPCValue()</tt>
03104         AK_EXTERNAPIFUNC( AKRESULT, ResetRTPCValue )(
03105             const wchar_t* in_pszRtpcName,                          ///< Name of the game parameter
03106             AkGameObjectID in_gameObjectID = AK_INVALID_GAME_OBJECT,///< Associated game object ID
03107             AkTimeMs in_uValueChangeDuration = 0,                   ///< Duration during which the game parameter is interpolated towards its default value
03108             AkCurveInterpolation in_eFadeCurve = AkCurveInterpolation_Linear,   ///< Curve type to be used for the game parameter interpolation
03109             bool in_bBypassInternalValueInterpolation = false       ///< True if you want to bypass the internal "slew rate" or "over time filtering" specified by the sound designer. This is meant to be used when for example loading a level and you dont want the values to interpolate.
03110             );
03111 #endif //AK_SUPPORT_WCHAR
03112 
03113         /// Resets the value of the game parameter to its default value, as specified in the Wwise project.
03114         /// With this function, you may reset a game parameter to its default value with global scope or with game object scope. 
03115         /// Game object scope supersedes global scope. Game parameter values reset with global scope are applied to all 
03116         /// game objects that were not overridden with a value with game object scope.
03117         /// To reset a game parameter value with global scope, pass AK_INVALID_GAME_OBJECT as the game object. 
03118         /// With this function, you may also reset the value of a game parameter over time. To do so, specify a non-zero 
03119         /// value for in_uValueChangeDuration. At each audio frame, the game parameter value will be updated internally 
03120         /// according to the interpolation curve. If you call SetRTPCValue() or ResetRTPCValue() with in_uValueChangeDuration = 0 in the 
03121         /// middle of an interpolation, the interpolation stops and the new value is set directly. 
03122         /// Refer to \ref soundengine_rtpc_pergameobject, \ref soundengine_rtpc_buses and 
03123         /// \ref soundengine_rtpc_effects for more details on RTPC scope.
03124         /// \return 
03125         /// - AK_Success if successful
03126         /// - AK_IDNotFound if in_pszParamName is NULL.
03127         /// \aknote Strings are case-insensitive. \endaknote
03128         /// \sa 
03129         /// - \ref soundengine_rtpc
03130         /// - <tt>AK::SoundEngine::SetRTPCValue()</tt>
03131         AK_EXTERNAPIFUNC( AKRESULT, ResetRTPCValue )(
03132             const char* in_pszRtpcName,                             ///< Name of the game parameter
03133             AkGameObjectID in_gameObjectID = AK_INVALID_GAME_OBJECT,///< Associated game object ID
03134             AkTimeMs in_uValueChangeDuration = 0,                   ///< Duration during which the game parameter is interpolated towards its default value
03135             AkCurveInterpolation in_eFadeCurve = AkCurveInterpolation_Linear,   ///< Curve type to be used for the game parameter interpolation
03136             bool in_bBypassInternalValueInterpolation = false       ///< True if you want to bypass the internal "slew rate" or "over time filtering" specified by the sound designer. This is meant to be used when for example loading a level and you dont want the values to interpolate.
03137             );
03138 
03139         /// Sets the State of a Switch Group (by IDs).
03140         /// \return Always returns AK_Success
03141         /// \sa 
03142         /// - \ref soundengine_switch
03143         /// - <tt>AK::SoundEngine::GetIDFromString()</tt>
03144         AK_EXTERNAPIFUNC( AKRESULT, SetSwitch )( 
03145             AkSwitchGroupID in_switchGroup,             ///< ID of the Switch Group
03146             AkSwitchStateID in_switchState,             ///< ID of the Switch
03147             AkGameObjectID in_gameObjectID              ///< Associated game object ID
03148             );
03149 
03150 #ifdef AK_SUPPORT_WCHAR
03151         /// Sets the State of a Switch Group (by Unicode string names).
03152         /// \return 
03153         /// - AK_Success if successful
03154         /// - AK_IDNotFound if the switch or Switch Group name was not resolved to an existing ID\n
03155         /// Make sure that the banks were generated with the "include string" option.
03156         /// \aknote Strings are case-insensitive. \endaknote
03157         /// \sa 
03158         /// - \ref soundengine_switch
03159         AK_EXTERNAPIFUNC( AKRESULT, SetSwitch )( 
03160             const wchar_t* in_pszSwitchGroup,           ///< Name of the Switch Group
03161             const wchar_t* in_pszSwitchState,           ///< Name of the Switch
03162             AkGameObjectID in_gameObjectID              ///< Associated game object ID
03163             );
03164 #endif //AK_SUPPORT_WCHAR
03165 
03166         /// Sets the state of a Switch Group.
03167         /// \return 
03168         /// - AK_Success if successful
03169         /// - AK_IDNotFound if the switch or Switch Group name was not resolved to an existing ID\n
03170         /// Make sure that the banks were generated with the "include string" option.
03171         /// \aknote Strings are case-insensitive. \endaknote
03172         /// \sa 
03173         /// - \ref soundengine_switch
03174         AK_EXTERNAPIFUNC( AKRESULT, SetSwitch )( 
03175             const char* in_pszSwitchGroup,              ///< Name of the Switch Group
03176             const char* in_pszSwitchState,              ///< Name of the Switch
03177             AkGameObjectID in_gameObjectID              ///< Associated game object ID
03178             );
03179 
03180         /// Post the specified trigger (by IDs).
03181         /// \return Always returns AK_Success
03182         /// \sa 
03183         /// - \ref soundengine_triggers
03184         /// - <tt>AK::SoundEngine::GetIDFromString()</tt>
03185         AK_EXTERNAPIFUNC( AKRESULT, PostTrigger )( 
03186             AkTriggerID     in_triggerID,               ///< ID of the trigger
03187             AkGameObjectID  in_gameObjectID             ///< Associated game object ID
03188             );
03189 
03190 #ifdef AK_SUPPORT_WCHAR
03191         /// Posts the specified trigger (by Unicode string name).
03192         /// \return 
03193         /// - AK_Success if successful
03194         /// - AK_IDNotFound if the trigger name was not resolved to an existing ID\n
03195         /// Make sure that the banks were generated with the "include string" option.
03196         /// \aknote Strings are case-insensitive. \endaknote
03197         /// \sa 
03198         /// - \ref soundengine_triggers
03199         AK_EXTERNAPIFUNC( AKRESULT, PostTrigger )( 
03200             const wchar_t* in_pszTrigger,               ///< Name of the trigger
03201             AkGameObjectID in_gameObjectID              ///< Associated game object ID
03202             );
03203 #endif //AK_SUPPORT_WCHAR
03204 
03205         /// Posts the specified trigger.
03206         /// \return 
03207         /// - AK_Success if successful
03208         /// - AK_IDNotFound if the trigger name was not resolved to an existing ID\n
03209         /// Make sure that the banks were generated with the "include string" option.
03210         /// \aknote Strings are case-insensitive. \endaknote
03211         /// \sa 
03212         /// - \ref soundengine_triggers
03213         AK_EXTERNAPIFUNC( AKRESULT, PostTrigger )( 
03214             const char* in_pszTrigger,                  ///< Name of the trigger
03215             AkGameObjectID in_gameObjectID              ///< Associated game object ID
03216             );
03217 
03218         /// Sets the state of a State Group (by IDs).
03219         /// \return Always returns AK_Success
03220         /// \sa 
03221         /// - \ref soundengine_states
03222         /// - <tt>AK::SoundEngine::GetIDFromString()</tt>
03223         AK_EXTERNAPIFUNC( AKRESULT, SetState )( 
03224             AkStateGroupID in_stateGroup,               ///< ID of the State Group
03225             AkStateID in_state                          ///< ID of the state
03226             );
03227 
03228 #ifdef AK_SUPPORT_WCHAR
03229         /// Sets the state of a State Group (by Unicode string names).
03230         /// \return 
03231         /// - AK_Success if successful
03232         /// - AK_IDNotFound if the state or State Group name was not resolved to an existing ID\n
03233         /// Make sure that the banks were generated with the "include string" option.
03234         /// \aknote Strings are case-insensitive. \endaknote
03235         /// \sa 
03236         /// - \ref soundengine_states
03237         /// - <tt>AK::SoundEngine::GetIDFromString()</tt>
03238         AK_EXTERNAPIFUNC( AKRESULT, SetState )( 
03239             const wchar_t* in_pszStateGroup,                ///< Name of the State Group
03240             const wchar_t* in_pszState                      ///< Name of the state
03241             );
03242 #endif //AK_SUPPORT_WCHAR
03243 
03244         /// Sets the state of a State Group.
03245         /// \return 
03246         /// - AK_Success if successful
03247         /// - AK_IDNotFound if the state or State Group name was not resolved to an existing ID\n
03248         /// Make sure that the banks were generated with the "include string" option.
03249         /// \aknote Strings are case-insensitive. \endaknote
03250         /// \sa 
03251         /// - \ref soundengine_states
03252         /// - <tt>AK::SoundEngine::GetIDFromString()</tt>
03253         AK_EXTERNAPIFUNC( AKRESULT, SetState )( 
03254             const char* in_pszStateGroup,                   ///< Name of the State Group
03255             const char* in_pszState                         ///< Name of the state
03256             );
03257 
03258         //@}
03259 
03260         ////////////////////////////////////////////////////////////////////////
03261         /// @name Environments
03262         //@{
03263 
03264         /// Sets the Auxiliary Busses to route the specified game object
03265         /// To clear the game object's auxiliary sends, \c in_uNumSendValues must be 0.
03266         /// \sa 
03267         /// - \ref soundengine_environments
03268         /// - \ref soundengine_environments_dynamic_aux_bus_routing
03269         /// - \ref soundengine_environments_id_vs_string
03270         /// - <tt>AK::SoundEngine::GetIDFromString()</tt>
03271         /// \return 
03272         /// - AK_Success if successful
03273         /// - AK_InvalidParameter if a duplicated environment is found in the array
03274         AK_EXTERNAPIFUNC( AKRESULT, SetGameObjectAuxSendValues )( 
03275             AkGameObjectID      in_gameObjectID,        ///< Associated game object ID
03276             AkAuxSendValue*     in_aAuxSendValues,      ///< Variable-size array of AkAuxSendValue structures
03277                                                         ///< (it may be NULL if no environment must be set)
03278             AkUInt32            in_uNumSendValues       ///< The number of auxiliary busses at the pointer's address
03279                                                         ///< (it must be 0 if no environment is set)
03280             );
03281 
03282         /// Registers a callback to allow the game to modify or override the volume to be applied at the output of an audio bus.
03283         /// The callback must be registered once per bus ID.
03284         /// Call with <tt>in_pfnCallback = NULL</tt> to unregister.
03285         /// \aknote The bus in_busID needs to be a mixing bus.\endaknote
03286         /// \aknote Beware when using this callback on the Master Audio Bus: since the output of this bus is not a bus, but is instead a system end-point, <tt>AkSpeakerVolumeMatrixCallbackInfo::pMixerContext</tt> will be \c NULL. You cannot modify panning at the output of the Master Audio Bus.\endaknote
03287         /// \sa 
03288         /// - \ref goingfurther_speakermatrixcallback
03289         /// - \ref soundengine_environments
03290         /// - AkSpeakerVolumeMatrixCallbackInfo
03291         /// - <tt>AK::IAkMixerInputContext</tt>
03292         /// - <tt>AK::IAkMixerPluginContext</tt>
03293         /// \return 
03294         /// - AK_Success if successful
03295         AK_EXTERNAPIFUNC( AKRESULT, RegisterBusVolumeCallback )( 
03296             AkUniqueID in_busID,                        ///< Bus ID, as obtained by GetIDFromString( bus_name ).
03297             AkBusCallbackFunc in_pfnCallback            ///< Callback function.
03298             );
03299 
03300         /// Registers a callback to be called to allow the game to access metering data from any mixing bus. You may use this to monitor loudness at any point of the mixing hierarchy 
03301         /// by querying the peak, RMS, True Peak and K-weighted power (according to loudness standard ITU BS.1770). See \ref goingfurther_speakermatrixcallback for an example.
03302         /// The callback must be registered once per bus ID.
03303         /// Call with in_pfnCallback = NULL to unregister.
03304         /// \aknote The bus in_busID needs to be a mixing bus.\endaknote
03305         /// \sa 
03306         /// - \ref goingfurther_speakermatrixcallback
03307         /// - AkBusMeteringCallbackFunc
03308         /// - <tt>AK::IAkMetering</tt>
03309         /// \return 
03310         /// - AK_Success if successful
03311         AK_EXTERNAPIFUNC( AKRESULT, RegisterBusMeteringCallback )( 
03312             AkUniqueID in_busID,                        ///< Bus ID, as obtained by GetIDFromString( bus_name ).
03313             AkBusMeteringCallbackFunc in_pfnCallback,   ///< Callback function.
03314             AkMeteringFlags in_eMeteringFlags           ///< Metering flags.
03315             );
03316 
03317         /// Sets the Output Bus Volume (direct) to be used for the specified game object.
03318         /// The control value is a number ranging from 0.0f to 1.0f.
03319         /// Output Bus Volumes are stored per listener association, so calling this function will override the default set of listeners. The game object in_emitterObjID will now reference its own set of listeners which will 
03320         /// be the same as the old set of listeners, but with the new associated gain.  Future changes to the default listener set will not be picked up by this game object unless ResetListenersToDefault() is called.
03321         /// \sa 
03322         /// - \ref AK::SoundEngine::ResetListenersToDefault
03323         /// - \ref soundengine_environments
03324         /// - \ref soundengine_environments_setting_dry_environment
03325         /// - \ref soundengine_environments_id_vs_string
03326         /// \return Always returns AK_Success
03327         AK_EXTERNAPIFUNC( AKRESULT, SetGameObjectOutputBusVolume )( 
03328             AkGameObjectID      in_emitterObjID,        ///< Associated emitter game object ID
03329             AkGameObjectID      in_listenerObjID,       ///< Associated listener game object ID. Pass AK_INVALID_GAME_OBJECT to set the Output Bus Volume for all connected listeners.
03330             AkReal32            in_fControlValue        ///< A multiplier where 0 means silence and 1 means no change. 
03331                                                         ///< (Therefore, values between 0 and 1 will attenuate the sound, and values greater than 1 will amplify it.)
03332             );
03333 
03334         /// Sets an Effect ShareSet at the specified audio node and Effect slot index.
03335         /// The target node cannot be a Bus, to set effects on a bus, use SetBusEffect() instead.
03336         /// \aknote The option "Override Parent" in 
03337         /// the Effect section in Wwise must be enabled for this node, otherwise the parent's effect will 
03338         /// still be the one in use and the call to SetActorMixerEffect will have no impact.
03339         /// \endaknote
03340         /// \return Always returns AK_Success
03341         AK_EXTERNAPIFUNC( AKRESULT, SetActorMixerEffect )( 
03342             AkUniqueID in_audioNodeID,                  ///< Can be a member of the Actor-Mixer or Interactive Music Hierarchy (not a bus).
03343             AkUInt32 in_uFXIndex,                       ///< Effect slot index (0-3)
03344             AkUniqueID in_shareSetID                    ///< ShareSets ID; pass AK_INVALID_UNIQUE_ID to clear the effect slot
03345             );
03346 
03347         /// Sets an Effect ShareSet at the specified bus and Effect slot index.
03348         /// The Bus can either be an Audio Bus or an Auxiliary Bus.
03349         /// This adds a reference on the audio node to an existing ShareSet.
03350         /// \aknote This function has unspecified behavior when adding an Effect to a currently playing
03351         /// Bus which does not have any Effects, or removing the last Effect on a currently playing bus.
03352         /// \endaknote
03353         /// \aknote This function will replace existing Effects on the node. If the target node is not at 
03354         /// the top of the hierarchy and is in the actor-mixer hierarchy, the option "Override Parent" in 
03355         /// the Effect section in Wwise must be enabled for this node, otherwise the parent's Effect will 
03356         /// still be the one in use and the call to SetBusEffect will have no impact.
03357         /// \endaknote
03358         /// \return Always returns AK_Success
03359         AK_EXTERNAPIFUNC( AKRESULT, SetBusEffect )( 
03360             AkUniqueID in_audioNodeID,                  ///< Bus Short ID.
03361             AkUInt32 in_uFXIndex,                       ///< Effect slot index (0-3)
03362             AkUniqueID in_shareSetID                    ///< ShareSets ID; pass AK_INVALID_UNIQUE_ID to clear the Effect slot
03363             );
03364 
03365 #ifdef AK_SUPPORT_WCHAR
03366         /// Sets an Effect ShareSet at the specified Bus and Effect slot index.
03367         /// The Bus can either be an Audio Bus or an Auxiliary Bus.
03368         /// This adds a reference on the audio node to an existing ShareSet.
03369         /// \aknote This function has unspecified behavior when adding an Effect to a currently playing
03370         /// bus which does not have any Effects, or removing the last Effect on a currently playing Bus.
03371         /// \endaknote
03372         /// \aknote This function will replace existing Effects on the node. If the target node is not at 
03373         /// the top of the hierarchy and is in the Actor-Mixer Hierarchy, the option "Override Parent" in 
03374         /// the Effect section in Wwise must be enabled for this node, otherwise the parent's Effect will 
03375         /// still be the one in use and the call to \c SetBusEffect will have no impact.
03376         /// \endaknote
03377         /// \returns AK_IDNotFound is name not resolved, returns AK_Success otherwise.
03378         AK_EXTERNAPIFUNC( AKRESULT, SetBusEffect )( 
03379             const wchar_t* in_pszBusName,               ///< Bus name
03380             AkUInt32 in_uFXIndex,                       ///< Effect slot index (0-3)
03381             AkUniqueID in_shareSetID                    ///< ShareSets ID; pass AK_INVALID_UNIQUE_ID to clear the effect slot
03382             );
03383 #endif //AK_SUPPORT_WCHAR
03384 
03385         /// Sets an Effect ShareSet at the specified Bus and Effect slot index.
03386         /// The Bus can either be an Audio Bus or an Auxiliary Bus.
03387         /// This adds a reference on the audio node to an existing ShareSet.
03388         /// \aknote This function has unspecified behavior when adding an Effect to a currently playing
03389         /// Bus which does not have any effects, or removing the last Effect on a currently playing bus.
03390         /// \endaknote
03391         /// \aknote This function will replace existing Effects on the node. If the target node is not at 
03392         /// the top of the hierarchy and is in the Actor-Mixer Hierarchy, the option "Override Parent" in 
03393         /// the Effect section in Wwise must be enabled for this node, otherwise the parent's Effect will 
03394         /// still be the one in use and the call to SetBusEffect will have no impact.
03395         /// \endaknote
03396         /// \returns AK_IDNotFound is name not resolved, returns AK_Success otherwise.
03397         AK_EXTERNAPIFUNC( AKRESULT, SetBusEffect )( 
03398             const char* in_pszBusName,      ///< Bus name
03399             AkUInt32 in_uFXIndex,           ///< Effect slot index (0-3)
03400             AkUniqueID in_shareSetID        ///< ShareSets ID; pass AK_INVALID_UNIQUE_ID to clear the effect slot
03401             );
03402 
03403         /// Sets a Mixer ShareSet at the specified bus.
03404         /// \aknote This function has unspecified behavior when adding a mixer to a currently playing
03405         /// Bus which does not have any Effects or mixer, or removing the last mixer on a currently playing Bus.
03406         /// \endaknote
03407         /// \aknote This function will replace existing mixers on the node. 
03408         /// \endaknote
03409         /// \return Always returns AK_Success
03410         AK_EXTERNAPIFUNC( AKRESULT, SetMixer )( 
03411             AkUniqueID in_audioNodeID,                  ///< Bus Short ID.
03412             AkUniqueID in_shareSetID                    ///< ShareSets ID; pass AK_INVALID_UNIQUE_ID to remove.
03413             );
03414 
03415 #ifdef AK_SUPPORT_WCHAR
03416         /// Sets a Mixer ShareSet at the specified bus.
03417         /// \aknote This function has unspecified behavior when adding a mixer to a currently playing
03418         /// bus which does not have any effects nor mixer, or removing the last mixer on a currently playing bus.
03419         /// \endaknote
03420         /// \aknote This function will replace existing mixers on the node. 
03421         /// \endaknote
03422         /// \returns AK_IDNotFound is name not resolved, returns AK_Success otherwise.
03423         AK_EXTERNAPIFUNC( AKRESULT, SetMixer )( 
03424             const wchar_t* in_pszBusName,               ///< Bus name
03425             AkUniqueID in_shareSetID                    ///< ShareSets ID; pass AK_INVALID_UNIQUE_ID to remove.
03426             );
03427 #endif //AK_SUPPORT_WCHAR
03428 
03429         /// Sets a Mixer ShareSet at the specified bus.
03430         /// \aknote This function has unspecified behavior when adding a mixer to a currently playing
03431         /// bus which does not have any effects nor mixer, or removing the last mixer on a currently playing bus.
03432         /// \endaknote
03433         /// \aknote This function will replace existing mixers on the node.
03434         /// \endaknote
03435         /// \returns AK_IDNotFound is name not resolved, returns AK_Success otherwise.
03436         AK_EXTERNAPIFUNC( AKRESULT, SetMixer )( 
03437             const char* in_pszBusName,      ///< Bus name
03438             AkUniqueID in_shareSetID        ///< ShareSets ID; pass AK_INVALID_UNIQUE_ID to remove.
03439             );
03440 
03441         /// Forces channel configuration for the specified bus.
03442         /// \aknote You cannot change the configuration of the master bus.\endaknote
03443         /// 
03444         /// \return Always returns AK_Success
03445         AK_EXTERNAPIFUNC(AKRESULT, SetBusConfig)(
03446             AkUniqueID in_audioNodeID,                  ///< Bus Short ID.
03447             AkChannelConfig in_channelConfig            ///< Desired channel configuration. An invalid configuration (from default constructor) means "as parent".
03448             );
03449 
03450 #ifdef AK_SUPPORT_WCHAR
03451         /// Forces channel configuration for the specified bus.
03452         /// \aknote You cannot change the configuration of the master bus.\endaknote
03453         /// 
03454         /// \returns AK_IDNotFound is name not resolved, returns AK_Success otherwise.
03455         AK_EXTERNAPIFUNC(AKRESULT, SetBusConfig)(
03456             const wchar_t* in_pszBusName,               ///< Bus name
03457             AkChannelConfig in_channelConfig            ///< Desired channel configuration. An invalid configuration (from default constructor) means "as parent".
03458             );
03459 #endif //AK_SUPPORT_WCHAR
03460 
03461         /// Forces channel configuration for the specified bus.
03462         /// \aknote You cannot change the configuration of the master bus.\endaknote
03463         /// 
03464         /// \returns AK_IDNotFound is name not resolved, returns AK_Success otherwise.
03465         AK_EXTERNAPIFUNC(AKRESULT, SetBusConfig)(
03466             const char* in_pszBusName,                  ///< Bus name
03467             AkChannelConfig in_channelConfig            ///< Desired channel configuration. An invalid configuration (from default constructor) means "as parent".
03468             );
03469 
03470         /// Sets a game object's obstruction and occlusion levels. If SetMultiplePositions were used, values are set for all positions.
03471         /// This function is used to affect how an object should be heard by a specific listener.
03472         /// \sa 
03473         /// - \ref soundengine_obsocc
03474         /// - \ref soundengine_environments
03475         /// \return Always returns AK_Success
03476         AK_EXTERNAPIFUNC( AKRESULT, SetObjectObstructionAndOcclusion )(  
03477             AkGameObjectID in_EmitterID,        ///< Emitter game object ID
03478             AkGameObjectID in_ListenerID,       ///< Listener game object ID
03479             AkReal32 in_fObstructionLevel,      ///< ObstructionLevel: [0.0f..1.0f]
03480             AkReal32 in_fOcclusionLevel         ///< OcclusionLevel: [0.0f..1.0f]
03481             );
03482 
03483         /// Sets a game object's obstruction and occlusion level for each positions defined by SetMultiplePositions.
03484         /// This function differs from SetObjectObstructionAndOcclusion as a list of obstruction/occlusion pair is provided
03485         /// and each obstruction/occlusion pair will affect the corresponding position defined at the same index.
03486         /// \aknote In the case the number of obstruction/occlusion pairs is smaller than the number of positions, remaining positions' 
03487         /// obstrucion/occlusion values are set to 0.0. \endaknote
03488         /// \sa
03489         /// - \ref soundengine_obsocc
03490         /// - \ref soundengine_environments
03491         /// \return AK_Success if occlusion/obstruction values are successfully stored for this emitter
03492         AK_EXTERNAPIFUNC( AKRESULT, SetMultipleObstructionAndOcclusion )(
03493             AkGameObjectID in_EmitterID,                                        ///< Emitter game object ID
03494             AkGameObjectID in_uListenerID,                                      ///< Listener game object ID
03495             AkObstructionOcclusionValues* in_fObstructionOcclusionValues,       ///< Array of obstruction/occlusion pairs to apply
03496                                                                                 ///< ObstructionLevel: [0.0f..1.0f]
03497                                                                                 ///< OcclusionLevel: [0.0f..1.0f]
03498             AkUInt32 in_uNumOcclusionObstruction                                ///< Number of obstruction/occlusion pairs specified in the provided array
03499             );
03500 
03501         /// Saves the playback history of container structures.
03502         /// This function will write history data for all currently loaded containers and instantiated game
03503         /// objects (for example, current position in Sequence Containers and previously played elements in
03504         /// Random Containers). 
03505         /// \remarks
03506         /// This function acquires the main audio lock, and may block the caller for several milliseconds.
03507         /// \sa 
03508         /// - <tt>AK::SoundEngine::SetContainerHistory()</tt>
03509         AK_EXTERNAPIFUNC( AKRESULT, GetContainerHistory)(
03510             AK::IWriteBytes * in_pBytes         ///< Pointer to IWriteBytes interface used to save the history.
03511             );
03512 
03513         /// Restores the playback history of container structures.
03514         /// This function will read history data from the passed-in stream reader interface, and apply it to all
03515         /// currently loaded containers and instantiated game objects. Game objects are matched by
03516         /// ID. History for unloaded structures and unknown game objects will be skipped.
03517         /// \remarks
03518         /// This function acquires the main audio lock, and may block the caller for several milliseconds.
03519         /// \sa 
03520         /// - <tt>AK::SoundEngine::GetContainerHistory()</tt>
03521         AK_EXTERNAPIFUNC(AKRESULT, SetContainerHistory)(
03522             AK::IReadBytes * in_pBytes          ///< Pointer to IReadBytes interface used to load the history.
03523             );
03524 
03525         //@}
03526         
03527         ////////////////////////////////////////////////////////////////////////
03528         /// @name Capture
03529         //@{
03530 
03531         /// Starts recording the sound engine audio output. 
03532         /// StartOutputCapture outputs a wav file per current output device of the sound engine.
03533         /// If more than one device is active, the system will create multiple files in the same output 
03534         /// directory and will append numbers at the end of the provided filename.
03535         ///
03536         /// If no device is running yet, the system will return success AK_Success despite doing nothing.
03537         /// Use \ref RegisterAudioDeviceStatusCallback to get notified when devices are created/destructed.
03538         ///
03539         /// \return AK_Success if successful, AK_Fail if there was a problem starting the output capture.
03540         /// \remark
03541         ///     - The sound engine opens a stream for writing using <tt>AK::IAkStreamMgr::CreateStd()</tt>. If you are using the
03542         ///         default implementation of the Stream Manager, file opening is executed in your implementation of 
03543         ///         the Low-Level IO interface <tt>AK::StreamMgr::IAkFileLocationResolver::Open()</tt>. The following 
03544         ///         AkFileSystemFlags are passed: uCompanyID = AKCOMPANYID_AUDIOKINETIC and uCodecID = AKCODECID_PCM,
03545         ///         and the AkOpenMode is AK_OpenModeWriteOvrwr. Refer to \ref streamingmanager_lowlevel_location for
03546         ///         more details on managing the deployment of your Wwise generated data.
03547         /// \sa 
03548         /// - <tt>AK::SoundEngine::StopOutputCapture()</tt>
03549         /// - <tt>AK::StreamMgr::SetFileLocationResolver()</tt>
03550         /// - \ref streamingdevicemanager
03551         /// - \ref streamingmanager_lowlevel_location
03552         AK_EXTERNAPIFUNC( AKRESULT, StartOutputCapture )( 
03553             const AkOSChar* in_CaptureFileName              ///< Name of the output capture file
03554             );
03555 
03556         /// Stops recording the sound engine audio output. 
03557         /// \return AK_Success if successful, AK_Fail if there was a problem stopping the output capture.
03558         /// \sa 
03559         /// - <tt>AK::SoundEngine::StartOutputCapture()</tt>
03560         AK_EXTERNAPIFUNC( AKRESULT, StopOutputCapture )();
03561 
03562         /// Adds text marker in audio output file. 
03563         /// \return AK_Success if successful, AK_Fail if there was a problem adding the output marker.
03564         /// \sa 
03565         /// - <tt>AK::SoundEngine::StartOutputCapture()</tt>
03566         AK_EXTERNAPIFUNC( AKRESULT, AddOutputCaptureMarker )(
03567             const char* in_MarkerText                   ///< Text of the marker
03568             );
03569             
03570         /// Starts recording the sound engine profiling information into a file. This file can be read
03571         /// by Wwise Authoring.
03572         /// \remark This function is provided as a utility tool only. It does nothing if it is 
03573         ///         called in the release configuration and returns AK_NotCompatible.
03574         AK_EXTERNAPIFUNC( AKRESULT, StartProfilerCapture )( 
03575             const AkOSChar* in_CaptureFileName              ///< Name of the output profiler file (.prof extension recommended)
03576             );
03577 
03578         /// Stops recording the sound engine profiling information. 
03579         /// \remark This function is provided as a utility tool only. It does nothing if it is 
03580         ///         called in the release configuration and returns AK_NotCompatible.
03581         AK_EXTERNAPIFUNC( AKRESULT, StopProfilerCapture )();
03582 
03583         //@}
03584 
03585         ////////////////////////////////////////////////////////////////////////
03586         /// @name Secondary Outputs
03587         //@{
03588 
03589         /// Adds an output to the sound engine. Use this to add controller-attached headphones, controller speakers, DVR output, etc.  
03590         /// The in_Settings parameter contains an Audio Device shareset to specify the output plugin to use and a device ID to specify the instance, if necessary (e.g. which game controller).
03591         /// \sa AkOutputSettings for more details.
03592         /// \sa \ref integrating_secondary_outputs
03593         /// \sa \ref default_audio_devices
03594         /// \return 
03595         /// - AK_NotImplemented: Feature not supported
03596         /// - AK_InvalidParameter: Out of range parameters or unsupported parameter combinations (see parameter list below).
03597         /// - AK_IDNotFound: Shareset ID doesn't exist.  Possibly, the Init bank isn't loaded yet or was not updated with latest changes.
03598         /// - AK_DeviceNotReady: The in_iDeviceID doesn't match with a valid hardware device.  Either the device doesn't exist or is disabled.  Disconnected devices (headphones) are not considered "not ready" therefore won't cause this error.
03599         /// - AK_Success: Parameters are valid.     
03600         AK_EXTERNAPIFUNC(AKRESULT, AddOutput)(          
03601             const AkOutputSettings & in_Settings,   ///< Creation parameters for this output.  \ref AkOutputSettings                            
03602             AkOutputDeviceID *out_pDeviceID = NULL, ///< (Optional) Output ID to use with all other Output management functions.  Leave to NULL if not required. \ref AK::SoundEngine::GetOutputID
03603             const AkGameObjectID* in_pListenerIDs = NULL,   ///< Specific listener(s) to attach to this device. 
03604                                                             ///< If specified, only the sounds routed to game objects linked to those listeners will play in this device.  
03605                                                             ///< It is necessary to have separate listeners if multiple devices of the same type can coexist (e.g. controller speakers)
03606                                                             ///< If not specified, sound routing simply obey the associations between Master Busses and Audio Devices setup in the Wwise Project.
03607             AkUInt32 in_uNumListeners = 0                   ///< The number of elements in the in_pListenerIDs array.
03608             );
03609 
03610         /// Removes one output added through AK::SoundEngine::AddOutput
03611         /// If a listener was associated with the device, you should consider unregistering the listener prior to call RemoveOutput 
03612         /// so that Game Object/Listener routing is properly updated according to your game scenario.
03613         /// \sa \ref integrating_secondary_outputs
03614         /// \sa AK::SoundEngine::AddOutput
03615         /// \return AK_Success: Parameters are valid.
03616         AK_EXTERNAPIFUNC(AKRESULT, RemoveOutput)(
03617             AkOutputDeviceID in_idOutput    ///< ID of the output to remove.  Use the returned ID from AddOutput or GetOutputID
03618             );
03619 
03620         /// Gets the compounded output ID from shareset and device id.
03621         /// Outputs are defined by their type (Audio Device shareset) and their specific system ID.  A system ID could be reused for other device types on some OS or platforms, hence the compounded ID.
03622         /// \return The id of the output                    
03623         AK_EXTERNAPIFUNC(AkOutputDeviceID, GetOutputID)(
03624             AkUniqueID in_idShareset,       ///< Audio Device ShareSet ID, as defined in the Wwise Project.  If needed, use AK::SoundEngine::GetIDFromString() to convert from a string.  Set to AK_INVALID_UNIQUE_ID to use the default.
03625             AkUInt32 in_idDevice            ///< Device specific identifier, when multiple devices of the same type are possible.  If only one device is possible, leave to 0.
03626                                             ///< - PS4 Controller-Speakers: UserID as returned from sceUserServiceGetLoginUserIdList
03627                                             ///< - XBoxOne Controller-Headphones: Use the AK::GetDeviceID function to get the ID from an IMMDevice. Find the player's device with the WASAPI API (IMMDeviceEnumerator, see Microsoft documentation) or use AK::GetDeviceIDFromName.
03628                                             ///< - Windows: Use AK::GetDeviceID or AK::GetDeviceIDFromName to get the correct ID.       
03629                                             ///< - All others output: use 0 to select the default device for that type.
03630             );
03631 
03632         AK_EXTERNAPIFUNC(AkOutputDeviceID, GetOutputID)(
03633             const char* in_szShareSet,          ///< Audio Device ShareSet Name, as defined in the Wwise Project.  If Null, will select the Default Output shareset (always available)
03634             AkUInt32 in_idDevice                ///< Device specific identifier, when multiple devices of the same type are possible.  If only one device is possible, leave to 0.
03635             ///< - PS4 Controller-Speakers: UserID as returned from sceUserServiceGetLoginUserIdList
03636             ///< - XBoxOne Controller-Headphones: Use the AK::GetDeviceID function to get the ID from an IMMDevice. Find the player's device with the WASAPI API (IMMDeviceEnumerator, see Microsoft documentation) or use AK::GetDeviceIDFromName.
03637             ///< - Windows: Use AK::GetDeviceID or AK::GetDeviceIDFromName to get the correct ID.       
03638             ///< - All others output: use 0 to select the default device for that type.
03639             );
03640 
03641         #ifdef AK_SUPPORT_WCHAR
03642         AK_EXTERNAPIFUNC(AkOutputDeviceID, GetOutputID)(
03643             const wchar_t* in_szShareSet,           ///< Audio Device ShareSet Name, as defined in the Wwise Project.  If Null, will select the Default Output shareset (always available)
03644             AkUInt32 in_idDevice            ///< Device specific identifier, when multiple devices of the same type are possible.  If only one device is possible, leave to 0.
03645             ///< - PS4 Controller-Speakers: UserID as returned from sceUserServiceGetLoginUserIdList
03646             ///< - XBoxOne Controller-Headphones: Use the AK::GetDeviceID function to get the ID from an IMMDevice. Find the player's device with the WASAPI API (IMMDeviceEnumerator, see Microsoft documentation) or use AK::GetDeviceIDFromName.
03647             ///< - Windows: Use AK::GetDeviceID or AK::GetDeviceIDFromName to get the correct ID.       
03648             ///< - All others output: use 0 to select the default device for that type.
03649             );
03650         #endif
03651 
03652         /// Sets the Audio Device to which a master bus outputs.  This overrides the setting in the Wwise project.  
03653         /// Can only be set on top-level busses. The Init bank should be successfully loaded prior to this call.
03654         /// \return 
03655         /// AK_IDNotFound when either the Bus ID or the Device ID are not present in the Init bank or the bank was not loaded
03656         /// AK_InvalidParameter when the specified bus is not a Master Bus.  This function can be called only on busses that have no parent bus.
03657         AK_EXTERNAPIFUNC(AKRESULT, SetBusDevice)(
03658             AkUniqueID in_idBus,            ///< Id of the master bus
03659             AkUniqueID in_idNewDevice       ///< New device shareset to replace with.
03660             );
03661 
03662         /// Sets the Audio Device to which a master bus outputs.  This overrides the setting in the Wwise project.  
03663         /// Can only be set on top-level busses. The Init bank should be successfully loaded prior to this call.
03664         /// \return 
03665         /// AK_IDNotFound when either the Bus ID or the Device ID are not present in the Init bank or the bank was not loaded
03666         /// AK_InvalidParameter when the specified bus is not a Master Bus.  This function can be called only on busses that have no parent bus.
03667         AK_EXTERNAPIFUNC(AKRESULT, SetBusDevice)(
03668             const char*  in_BusName,        ///< Name of the master bus
03669             const char*  in_DeviceName      ///< New device shareset to replace with.
03670             );
03671 
03672         #ifdef AK_SUPPORT_WCHAR
03673         /// Sets the Audio Device to which a master bus outputs.  This overrides the setting in the Wwise project.  
03674         /// Can only be set on top-level busses. The Init bank should be successfully loaded prior to this call.
03675         /// \return 
03676         /// AK_IDNotFound when either the Bus ID or the Device ID are not present in the Init bank or the bank was not loaded
03677         /// AK_InvalidParameter when the specified bus is not a Master Bus.  This function can be called only on busses that have no parent bus.
03678         AK_EXTERNAPIFUNC(AKRESULT, SetBusDevice)(
03679             const wchar_t*  in_BusName,     ///< Name of the master bus
03680             const wchar_t*  in_DeviceName   ///< New device shareset to replace with.
03681             );
03682         #endif
03683         
03684         /// Sets the volume of a output device.     
03685         AK_EXTERNAPIFUNC( AKRESULT, SetOutputVolume )(
03686             AkOutputDeviceID in_idOutput,   ///< Output ID to set the volume on.  As returned from AddOutput or GetOutputID
03687             AkReal32 in_fVolume             ///< Volume (0.0 = Muted, 1.0 = Volume max)
03688             );
03689 
03690         //@}
03691 
03692         /// This function should be called to put the sound engine in background mode, where audio isn't processed anymore. This needs to be called if the console has a background mode or some suspended state.
03693         /// Call \c WakeupFromSuspend when your application receives the message from the OS that the process is back in foreground.
03694         /// When suspended, the sound engine will process API messages (like PostEvent and SetSwitch) only when \ref RenderAudio() is called. 
03695         /// It is recommended to match the <b>in_bRenderAnyway</b> parameter with the behavior of the rest of your game: 
03696         /// if your game still runs in background and you must keep some kind of coherent state between the audio engine and game, then allow rendering.
03697         /// If you want to minimize CPU when in background, then don't allow rendering and never call RenderAudio from the game.
03698         ///
03699         /// - Android: Call for APP_CMD_PAUSE
03700         /// - iOS: Don't call. All audio interrupts are handled internally.
03701         /// - XBoxOne: Use when entering constrained mode or suspended mode (see ResourceAvailability in Xbox One documentation).
03702         /// \sa \ref WakeupFromSuspend
03703         AK_EXTERNAPIFUNC( AKRESULT, Suspend )(
03704             bool in_bRenderAnyway = false /// If set to true, audio processing will still occur, but not outputted. When set to false, no audio will be processed at all, even upon reception of RenderAudio().
03705             );
03706 
03707         /// This function should be called to wake up the sound engine and start processing audio again. This needs to be called if the console has a background mode or some suspended state.
03708         /// - Android: Call for APP_CMD_RESUME
03709         /// - iOS: Don't call. All audio interrupts are handled internally.     
03710         /// - XBoxOne: Use when the game is back to Full resources (see ResourceAvailability in Xbox One documentation).
03711         AK_EXTERNAPIFUNC( AKRESULT, WakeupFromSuspend )(); 
03712 
03713         /// Obtains the current audio output buffer tick. This corresponds to the number of buffers produced by
03714         /// the sound engine since initialization. 
03715         /// \return Tick count.
03716         AK_EXTERNAPIFUNC(AkUInt32, GetBufferTick)();
03717     }
03718 }
03719 
03720 #endif // _AK_SOUNDENGINE_H_