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