_ak_query_parameters_8h

Wwise SDK 2025.1.4

 /*******************************************************************************
 The content of this file includes portions of the AUDIOKINETIC Wwise Technology
 released in source code form as part of the SDK installer package.
  
 Commercial License Usage
  
 Licensees holding valid commercial licenses to the AUDIOKINETIC Wwise Technology
 may use this file in accordance with the end user license agreement provided 
 with the software or, alternatively, in accordance with the terms contained in a
 written agreement between you and Audiokinetic Inc.
  
 Apache License Usage
  
 Alternatively, this file may be used under the Apache License, Version 2.0 (the 
 "Apache License"); you may not use this file except in compliance with the 
 Apache License. You may obtain a copy of the Apache License at 
 http://www.apache.org/licenses/LICENSE-2.0.
  
 Unless required by applicable law or agreed to in writing, software distributed
 under the Apache License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES
 OR CONDITIONS OF ANY KIND, either express or implied. See the Apache License for
 the specific language governing permissions and limitations under the License.
  
   Copyright (c) 2025 Audiokinetic Inc.
 *******************************************************************************/
  
 // AkQueryParameters.h
  
 /// \file 
 /// The sound engine parameter query interface.
  
  
 #ifndef _AK_QUERYPARAMS_H_
 #define _AK_QUERYPARAMS_H_
  
 #include AK/SoundEngine/Common/AkSoundEngineExport.h>
 #include AK/SoundEngine/Common/AkTypes.h>
 #include AK/SoundEngine/Common/AkCommonDefs.h>
 #include AK/Tools/Common/AkArray.h>
  
 /// Positioning information obtained from an object
 struct AkPositioningInfo
 {
     AkReal32            fCenterPct;         ///
     AkSpeakerPanningType    pannerType;     ///
     Ak3DPositionType    e3dPositioningType; ///
     bool                bHoldEmitterPosAndOrient;   ///
     Ak3DSpatializationMode e3DSpatializationMode; ///
     bool                bEnableAttenuation; ///
  
     bool                bUseConeAttenuation; ///
     AkReal32            fInnerAngle;        ///
     AkReal32            fOuterAngle;        ///
     AkReal32            fConeMaxAttenuation; ///
     AkLPFType           LPFCone;            ///
     AkLPFType           HPFCone;            ///
  
     AkReal32            fMaxDistance;       ///
     AkReal32            fVolDryAtMaxDist;   ///
     AkReal32            fVolAuxGameDefAtMaxDist;    ///
     AkReal32            fVolAuxUserDefAtMaxDist;    ///
     AkLPFType           LPFValueAtMaxDist;  ///
     AkLPFType           HPFValueAtMaxDist;  ///
 };
  
 /// Object information structure for QueryAudioObjectsIDs
 struct AkObjectInfo
 {
     AkUniqueID  objID;      ///
     AkUniqueID  parentID;   ///
     AkInt32     iDepth;     ///
 };
  
 // Audiokinetic namespace
 namespace AK
 {
     // Audiokinetic sound engine namespace
     namespace SoundEngine
     {
         /// Query namespace
         /// \remarks The functions in this namespace are thread-safe, unless stated otherwise. We recommend that you use these functions in development builds only, because they can cause CPU spikes.
         ///
         /// \akwarning
         /// The functions in this namespace might stall for several milliseconds before returning
         /// because they cannot execute while the main sound engine tick is running. 
         /// They should therefore not be called from any game-critical thread, such as the main game loop. 
         /// However, if the function definition states that it does not require the main audio lock, no delay should occur.
         ///
         /// There might be a significant delay between a Sound Engine call, such as PostEvent, and
         /// the information being returned in a Query, such as GetIsGameObjectActive. 
         /// \endakwarning
  
         namespace Query
         {
             ////////////////////////////////////////////////////////////////////////
             /// @name Game Objects
             //@{
  
             /// Get the position of a game object.
             /// \return AK_Success if succeeded, or AK_IDNotFound if the game object was not registered
             /// \sa 
             /// - \ref soundengine_3dpositions
             AK_EXTERNAPIFUNC( AKRESULT, GetPosition )( 
                 AkGameObjectID in_GameObjectID,             ///
                 AkSoundPosition& out_rPosition              ///
                 );
  
             //@}
  
             ////////////////////////////////////////////////////////////////////////
             /// @name Listeners
             //@{
  
             /// Get a game object's listeners.  
             /// \return AK_Success if succeeded, or AK_IDNotFound if the game object was not registered
             /// \sa 
             /// - \ref soundengine_listeners
             AK_EXTERNAPIFUNC( AKRESULT, GetListeners )(
                 AkGameObjectID in_GameObjectID,             ///
                 AkGameObjectID* out_ListenerObjectIDs,      ///
                 AkUInt32& oi_uNumListeners                  ///
                 );
  
             /// Get a listener's position.
             /// \return AK_Success if succeeded, or AK_InvalidParameter if the index is out of range
             /// \sa 
             /// - \ref soundengine_listeners_settingpos
             AK_EXTERNAPIFUNC( AKRESULT, GetListenerPosition )( 
                 AkGameObjectID in_uListenerID,                  ///
                 AkListenerPosition& out_rPosition           ///
                 );
  
             /// Get a listener's spatialization parameters. 
             /// \return AK_Success if succeeded, or AK_InvalidParameter if the index is out of range
             /// \sa 
             /// - AK::SoundEngine::SetListenerSpatialization().
             /// - \ref soundengine_listeners_spatial
             AK_EXTERNAPIFUNC( AKRESULT, GetListenerSpatialization )(
                 AkGameObjectID in_uListenerID,              ///
                 bool& out_rbSpatialized,                    ///
                 AK::SpeakerVolumes::VectorPtr & out_pVolumeOffsets, ///
                 AkChannelConfig &out_channelConfig          ///
                 );
             
             //@}
  
  
             ////////////////////////////////////////////////////////////////////////
             /// @name Game Syncs
             //@{
  
             /// Enum used to request a specific RTPC Value.
             /// Also used to inform the user of where the RTPC Value comes from.
             ///
             /// For example, the user may request the GameObject specific value by specifying RTPCValue_GameObject
             /// and can receive the Global Value if there was no GameObject specific value, and even the 
             /// default value is there was no Global value either.
             /// \sa 
             /// - GetRTPCValue
             enum RTPCValue_type
             {
                 RTPCValue_Default,      ///
                 RTPCValue_Global,       ///
                 RTPCValue_GameObject,   ///
                 RTPCValue_PlayingID,    ///
                 RTPCValue_Unavailable,  ///
                 RTPCValue_Last,         ///
             };
  
             /// Get the value of a real-time parameter control (by ID)
             /// An RTPC can have a any combination of a global value, a unique value for each game object, or a unique value for each playing ID (Event).
             /// The value requested is determined by RTPCValue_type, in_gameObjectID and in_playingID.  
             /// If a value at the requested scope (determined by RTPCValue_type) is not found, the value that is available at the the next broadest scope will be returned, and io_rValueType will be changed to indicate this.
             /// \note
             ///     When looking up RTPC values via playing ID (ie. io_rValueType is RTPC_PlayingID), in_gameObjectID can be set to a specific game object (if it is available to the caller) to use as a fall back value.
             ///     If the game object is unknown or unavailable, AK_INVALID_GAME_OBJECT can be passed in in_gameObjectID, and the game object will be looked up via in_playingID.  
             ///     However in this case, it is not possible to retrieve a game object value as a fall back value if the playing id does not exist.  It is best to pass in the game object if possible.
             /// \note
             ///     Contrary to most AK::Query functions, GetRTPCValue does not block. This means that GetRTPCValue does not wait for all previous API to be completed (which may take several milliseconds), 
             ///     and instead returns the current value. Therefore calling SetRTPCValue, RenderAudio and then GetRTPCValue might not immediately give the value set by SetRTPCValue.
             /// \return
             /// - AK_Success if succeeded
             /// - AK_IDNotFound if the RTPC does not exist
             /// - AK_InvalidID if the GameObject does not exist.
             /// \sa 
             /// - \ref soundengine_rtpc
             /// - RTPCValue_type
             AK_EXTERNAPIFUNC(AKRESULT, GetRTPCValue)(
                 AkRtpcID in_rtpcID,                 ///
                 AkGameObjectID in_gameObjectID,     ///
                 AkPlayingID in_playingID,           ///
                 AkRtpcValue& out_rValue,            ///
                 RTPCValue_type& io_rValueType       ///
                 );
  
 #ifdef AK_SUPPORT_WCHAR
  
             /// Get the value of a real-time parameter control (by ID)
             /// An RTPC can have a any combination of a global value, a unique value for each game object, or a unique value for each playing ID.  
             /// The value requested is determined by RTPCValue_type, in_gameObjectID and in_playingID.  
             /// If a value at the requested scope (determined by RTPCValue_type) is not found, the value that is available at the the next broadest scope will be returned, and io_rValueType will be changed to indicate this.
             /// \note
             ///     When looking up RTPC values via playing ID (ie. io_rValueType is RTPC_PlayingID), in_gameObjectID can be set to a specific game object (if it is available to the caller) to use as a fall back value.
             ///     If the game object is unknown or unavailable, AK_INVALID_GAME_OBJECT can be passed in in_gameObjectID, and the game object will be looked up via in_playingID.  
             ///     However in this case, it is not possible to retrieve a game object value as a fall back value if the playing id does not exist.  It is best to pass in the game object if possible.
             /// \note
             ///     Contrary to most AK::Query functions, GetRTPCValue does not block. This means that GetRTPCValue does not wait for all previous API to be completed (which may take several milliseconds), 
             ///     and instead returns the current value. Therefore calling SetRTPCValue, RenderAudio and then GetRTPCValue might not immediately give the value set by SetRTPCValue.
             /// \return
             /// - AK_Success if succeeded
             /// - AK_IDNotFound if the RTPC does not exist
             /// - AK_InvalidID if the GameObject does not exist.
             /// \sa 
             /// - \ref soundengine_rtpc
             /// - RTPCValue_type
             AK_EXTERNAPIFUNC(AKRESULT, GetRTPCValue)(
                 const wchar_t* in_pszRtpcName,      ///
                 AkGameObjectID in_gameObjectID,     ///
                 AkPlayingID in_playingID,           ///
                 AkRtpcValue& out_rValue,            ///
                 RTPCValue_type& io_rValueType       ///
                 );
  
 #endif //AK_SUPPORT_WCHAR
  
             /// Get the value of a real-time parameter control (by ID)
             /// An RTPC can have a any combination of a global value, a unique value for each game object, or a unique value for each playing ID.  
             /// The value requested is determined by RTPCValue_type, in_gameObjectID and in_playingID.  
             /// If a value at the requested scope (determined by RTPCValue_type) is not found, the value that is available at the the next broadest scope will be returned, and io_rValueType will be changed to indicate this.
             /// \note
             ///     When looking up RTPC values via playing ID (ie. io_rValueType is RTPC_PlayingID), in_gameObjectID can be set to a specific game object (if it is available to the caller) to use as a fall back value.
             ///     If the game object is unknown or unavailable, AK_INVALID_GAME_OBJECT can be passed in in_gameObjectID, and the game object will be looked up via in_playingID.  
             ///     However in this case, it is not possible to retrieve a game object value as a fall back value if the playing id does not exist.  It is best to pass in the game object if possible.
             /// \note
             ///     Contrary to most AK::Query functions, GetRTPCValue does not block. This means that GetRTPCValue does not wait for all previous API to be completed (which may take several milliseconds), 
             ///     and instead returns the current value. Therefore calling SetRTPCValue, RenderAudio and then GetRTPCValue might not immediately give the value set by SetRTPCValue.
             /// \return
             /// - AK_Success if succeeded
             /// - AK_IDNotFound if the RTPC does not exist
             /// - AK_InvalidID if the GameObject does not exist.
             /// \sa 
             /// - \ref soundengine_rtpc
             /// - RTPCValue_type
             AK_EXTERNAPIFUNC(AKRESULT, GetRTPCValue)(
                 const char* in_pszRtpcName,         ///
                 AkGameObjectID in_gameObjectID,     ///
                 AkPlayingID in_playingID,           ///
                 AkRtpcValue& out_rValue,            ///
                 RTPCValue_type& io_rValueType       ///
                 );
  
             /// Get the current Switch value of the specified Switch Group, for a game object 
             /// \note
             ///     Contrary to most AK::Query functions, GetSwitch does not block. This means that GetSwitch does not wait for all previous API to be completed (which may take several milliseconds), 
             ///     and instead returns the current value. Therefore calling SetSwitch, RenderAudio and then GetSwitch might not immediately give the value set by SetSwitch.
             /// \return
             /// - AK_Success if succeeded
             /// - AK_IDNotFound if the RTPC does not exist
             /// - AK_InvalidID if the GameObject does not exist.
             /// \return AK_Success if succeeded, or AK_IDNotFound if the game object was not registered or the Switch Group name cannot be found
             /// \sa 
             /// - \ref soundengine_switch
             /// - \ref AK::SoundEngine::SetSwitch
             AK_EXTERNAPIFUNC( AKRESULT, GetSwitch )( 
                 AkSwitchGroupID in_switchGroup,             ///
                 AkGameObjectID  in_gameObjectID,            ///
                 AkSwitchStateID& out_rSwitchState           ///
                 );
  
 #ifdef AK_SUPPORT_WCHAR
             /// Get the current Switch value of the specified Switch Group, for a game object 
             /// \return AK_Success if succeeded, or AK_IDNotFound if the game object was not registered or the Switch Group name cannot be found
             /// \sa 
             /// - \ref soundengine_switch
             /// - \ref AK::SoundEngine::SetSwitch
             AK_EXTERNAPIFUNC( AKRESULT, GetSwitch )( 
                 const wchar_t* in_pstrSwitchGroupName,      ///
                 AkGameObjectID in_GameObj,                  ///
                 AkSwitchStateID& out_rSwitchState           ///
                 );
 #endif //AK_SUPPORT_WCHAR
  
             /// Get the current Switch value of the specified Switch Group, for a game object 
             /// \return AK_Success if succeeded, or AK_IDNotFound if the game object was not registered or the Switch Group name cannot be found
             /// \sa 
             /// - \ref soundengine_switch
             /// - \ref AK::SoundEngine::SetSwitch
             AK_EXTERNAPIFUNC( AKRESULT, GetSwitch )( 
                 const char* in_pstrSwitchGroupName,         ///
                 AkGameObjectID in_GameObj,                  ///
                 AkSwitchStateID& out_rSwitchState           ///
                 );
  
             /// Get the current State value active in the specified State Group.
             /// \return AK_Success if succeeded
             /// \sa 
             /// - \ref soundengine_states
             /// - \ref AK::SoundEngine::SetState
             AK_EXTERNAPIFUNC( AKRESULT, GetState )( 
                 AkStateGroupID in_stateGroup,               ///
                 AkStateID& out_rState                       ///
                 );
  
 #ifdef AK_SUPPORT_WCHAR
             /// Get the current State value active in the specified State Group.
             /// \return AK_Success if succeeded
             /// \sa 
             /// - \ref soundengine_states
             /// - \ref AK::SoundEngine::SetState
             AK_EXTERNAPIFUNC( AKRESULT, GetState )( 
                 const wchar_t* in_pstrStateGroupName,       ///
                 AkStateID& out_rState                       ///
                 );
 #endif //AK_SUPPORT_WCHAR
  
             /// Get the current State value active in the specified State Group.
             /// \return AK_Success if succeeded
             /// \sa 
             /// - \ref soundengine_states
             /// - \ref AK::SoundEngine::SetState
             AK_EXTERNAPIFUNC( AKRESULT, GetState )( 
                 const char* in_pstrStateGroupName,          ///
                 AkStateID& out_rState                       ///
                 );
  
             //@}
  
             ////////////////////////////////////////////////////////////////////////
             /// @name Environments
             //@{
  
             /// Get the environmental ratios used by the specified game object.
             /// \sa 
             /// - \ref soundengine_environments
             /// - \ref soundengine_environments_dynamic_aux_bus_routing
             /// - \ref soundengine_environments_id_vs_string
             /// \return AK_Success if succeeded, or AK_InvalidParameter if io_ruNumSendValues is 0 or out_paEnvironmentValues is NULL, or AK_PartialSuccess if more environments exist than io_ruNumSendValues
             AK_EXTERNAPIFUNC( AKRESULT, GetGameObjectAuxSendValues )( 
                 AkGameObjectID      in_gameObjectID,        ///
                 AkAuxSendValue*     out_paAuxSendValues,    ///
                                                                 ///
                 AkUInt32&           io_ruNumSendValues      ///
                                                             ///
                 );
  
             /// Get the environmental dry level to be used for the specified game object
             /// The control value is a number ranging from 0.0f to 1.0f.
             /// 0.0f stands for 0% dry, while 1.0f stands for 100% dry.
             /// \aknote Reducing the dry level does not mean increasing the wet level. \endaknote
             /// \sa 
             /// - \ref soundengine_environments
             /// - \ref soundengine_environments_setting_dry_environment
             /// - \ref soundengine_environments_id_vs_string
             /// \return AK_Success if succeeded, or AK_IDNotFound if the game object was not registered
             AK_EXTERNAPIFUNC( AKRESULT, GetGameObjectDryLevelValue )( 
                 AkGameObjectID      in_EmitterID,           ///
                 AkGameObjectID      in_ListenerID,          ///
                 AkReal32&           out_rfControlValue      ///
                                                             ///
                 );
  
             /// Get a game object's obstruction and occlusion levels.
             /// \sa 
             /// - \ref soundengine_obsocc
             /// - \ref soundengine_environments
             /// \return AK_Success if succeeded, AK_IDNotFound if the game object was not registered
             AK_EXTERNAPIFUNC( AKRESULT, GetObjectObstructionAndOcclusion )(  
                 AkGameObjectID in_EmitterID,            ///
                 AkGameObjectID in_ListenerID,           ///
                 AkReal32& out_rfObstructionLevel,       ///
                 AkReal32& out_rfOcclusionLevel          ///
                 );
  
             //@}
  
             /// Get the list of audio object IDs associated to an event.
             /// \aknote It is possible to call QueryAudioObjectIDs with io_ruNumItems = 0 to get the total size of the
             /// structure that should be allocated for out_aObjectInfos. \endaknote
             /// \return AK_Success if succeeded, AK_IDNotFound if the eventID cannot be found, AK_InvalidParameter if out_aObjectInfos is NULL while io_ruNumItems > 0
             /// or AK_PartialSuccess if io_ruNumItems was set to 0 to query the number of available items.
             AK_EXTERNAPIFUNC( AKRESULT, QueryAudioObjectIDs )(
                 AkUniqueID in_eventID,              ///
                 AkUInt32& io_ruNumItems,            ///
                 AkObjectInfo* out_aObjectInfos      ///
                 );
  
 #ifdef AK_SUPPORT_WCHAR
             /// Get the list of audio object IDs associated to a event name.
             /// \aknote It is possible to call QueryAudioObjectIDs with io_ruNumItems = 0 to get the total size of the
             /// structure that should be allocated for out_aObjectInfos. \endaknote
             /// \return AK_Success if succeeded, AK_IDNotFound if the event name cannot be found, AK_InvalidParameter if out_aObjectInfos is NULL while io_ruNumItems > 0
             /// or AK_PartialSuccess if io_ruNumItems was set to 0 to query the number of available items.
             AK_EXTERNAPIFUNC( AKRESULT, QueryAudioObjectIDs )(
                 const wchar_t* in_pszEventName,     ///
                 AkUInt32& io_ruNumItems,            ///
                 AkObjectInfo* out_aObjectInfos      ///
                 );
 #endif //AK_SUPPORT_WCHAR
  
             /// Get the list of audio object IDs associated to an event name.
             /// \aknote It is possible to call QueryAudioObjectIDs with io_ruNumItems = 0 to get the total size of the
             /// structure that should be allocated for out_aObjectInfos. \endaknote
             /// \return AK_Success if succeeded, AK_IDNotFound if the event name cannot be found, AK_InvalidParameter if out_aObjectInfos is NULL while io_ruNumItems > 0
             /// or AK_PartialSuccess if io_ruNumItems was set to 0 to query the number of available items.
             AK_EXTERNAPIFUNC( AKRESULT, QueryAudioObjectIDs )(
                 const char* in_pszEventName,        ///
                 AkUInt32& io_ruNumItems,            ///
                 AkObjectInfo* out_aObjectInfos      ///
                 );
  
             /// Get positioning information associated to an audio object.
             /// \return AK_Success if succeeded, AK_IDNotFound if the object ID cannot be found, AK_NotCompatible if the audio object cannot expose positioning
             AK_EXTERNAPIFUNC( AKRESULT, GetPositioningInfo )( 
                 AkUniqueID in_ObjectID,                     ///
                 AkPositioningInfo& out_rPositioningInfo     ///
                 );
  
             /// List passed to GetActiveGameObjects.
             /// After calling this function, the list will contain the list of all game objects that are currently active in the sound engine.
             /// Being active means that either a sound is playing or pending to be played using this game object.
             /// The caller is responsible for calling Term() on the list when the list is not required anymore
             /// \sa 
             /// - GetActiveGameObjects
             typedef AkArray AkGameObjectsList;
  
             /// Fill the provided list with all the game object IDs that are currently active in the sound engine.
             /// The function may be used to avoid updating game objects positions that are not required at the moment.
             /// After calling this function, the list will contain the list of all game objects that are currently active in the sound engine.
             /// Being active means that either a sound is playing or pending to be played using this game object.
             /// \sa 
             /// - AkGameObjectsList
             AK_EXTERNAPIFUNC( AKRESULT, GetActiveGameObjects )( 
                 AkGameObjectsList& io_GameObjectList    ///
                 );
  
             /// Query if the specified game object is currently active.
             /// Being active means that either a sound is playing or pending to be played using this game object.
             AK_EXTERNAPIFUNC( bool, GetIsGameObjectActive )( 
                 AkGameObjectID in_GameObjId ///
                 );
  
             /// Game object and max distance association.
             /// \sa 
             /// - \ref AkRadiusList
             struct GameObjDst
             {
                 /// Default constructor
                 GameObjDst()
                     : m_gameObjID( AK_INVALID_GAME_OBJECT )
                     , m_dst( -1.0f )
                 {}
  
                 /// Easy constructor
                 GameObjDst( AkGameObjectID in_gameObjID, AkReal32 in_dst )
                     : m_gameObjID( in_gameObjID )
                     , m_dst( in_dst )
                 {}
  
                 AkGameObjectID  m_gameObjID;    ///
                 AkReal32        m_dst;          ///
             };
  
             /// List passed to GetMaxRadius.
             /// \sa 
             /// - \ref AK::SoundEngine::Query::GetMaxRadius
             typedef AkArray AkRadiusList;
  
             /// Returns the maximum distance used in attenuations associated to all sounds currently playing.
             /// This may be used for example by the game to know if some processing need to be performed on the game side, that would not be required
             /// if the object is out of reach anyway.
             ///
             /// Example usage:
             /// \code
             /// /*******************************************************/
             /// AkRadiusList RadLst; //creating the list( array ).
             /// // Do not reserve any size for the array, 
             /// // the system will reserve the correct size.
             ///
             /// GetMaxRadius( RadLst );
             /// // Use the content of the list
             /// (...)
             ///
             /// RadLst.Term();// the user is responsible to free the memory allocated
             /// /*******************************************************/
             /// \endcode
             ///
             /// \aknote The returned value is NOT the distance from a listener to an object but
             /// the maximum attenuation distance of all sounds playing on this object. This is
             /// not related in any way to the current 3D position of the object. \endaknote
             ///
             /// \return 
             /// - AK_Success if succeeded
             /// - AK_InsufficientMemory if there was not enough memory
             ///
             /// \aknote 
             /// The Scaling factor (if one was specified on the game object) is included in the return value.
             /// The Scaling factor is not updated once a sound starts playing since it 
             /// is computed only when the playback starts with the initial scaling factor of this game object. Scaling factor will 
             /// be re-computed for every playback instance, always using the scaling factor available at this time.
             /// \endaknote
             ///
             /// \sa 
             /// - AkRadiusList
             AK_EXTERNAPIFUNC( AKRESULT, GetMaxRadius )(
                 AkRadiusList & io_RadiusList    ///
                 );
  
             /// Returns the maximum distance used in attenuations associated to sounds playing using the specified game object.
             /// This may be used for example by the game to know if some processing need to be performed on the game side, that would not be required
             /// if the object is out of reach anyway.
             /// 
             /// \aknote The returned value is NOT the distance from a listener to an object but the maximum attenuation distance of all sounds playing on this object. \endaknote
             ///
             /// \return
             /// - A negative number if the game object specified is not playing.
             /// - 0, if the game object was only associated to sounds playing using no distance attenuation.
             /// - A positive number represents the maximum of all the distance attenuations playing on this game object.
             ///
             /// \aknote 
             /// The Scaling factor (if one was specified on the game object) is included in the return value.
             /// The Scaling factor is not updated once a sound starts playing since it 
             /// is computed only when the playback starts with the initial scaling factor of this game object. Scaling factor will 
             /// be re-computed for every playback instance, always using the scaling factor available at this time.
             /// \endaknote
             ///
             /// \sa 
             /// - \ref AK::SoundEngine::SetScalingFactor
             AK_EXTERNAPIFUNC( AkReal32, GetMaxRadius )(
                 AkGameObjectID in_GameObjId ///
                 );
  
             /// Get the Event ID associated to the specified PlayingID.
             /// This function does not acquire the main audio lock.
             ///
             /// \return AK_INVALID_UNIQUE_ID on failure.
             AK_EXTERNAPIFUNC( AkUniqueID, GetEventIDFromPlayingID )(
                 AkPlayingID in_playingID ///
                 );
  
             /// Get the ObjectID associated to the specified PlayingID.
             /// This function does not acquire the main audio lock.
             ///
             /// \return AK_INVALID_GAME_OBJECT on failure.
             AK_EXTERNAPIFUNC( AkGameObjectID, GetGameObjectFromPlayingID )(
                 AkPlayingID in_playingID ///
                 );
  
             /// Get the list PlayingIDs associated with the given game object.
             /// This function does not acquire the main audio lock.
             ///
             /// \aknote It is possible to call GetPlayingIDsFromGameObject with io_ruNumItems = 0 to get the total size of the
             /// structure that should be allocated for out_aPlayingIDs. \endaknote
             /// \return AK_Success if succeeded, AK_InvalidParameter if out_aPlayingIDs is NULL while io_ruNumItems > 0
             AK_EXTERNAPIFUNC( AKRESULT, GetPlayingIDsFromGameObject )(
                 AkGameObjectID in_GameObjId,        ///
                 AkUInt32& io_ruNumIDs,              ///
                 AkPlayingID* out_aPlayingIDs        ///
                 );
  
             /// Get the value of a custom property of integer or boolean type.
             /// \return AK_PartialSuccess if the object was found but no matching custom property was found on this object. Note that it could mean this value is the default value. 
             AK_EXTERNAPIFUNC( AKRESULT, GetCustomPropertyValue )(
                 AkUniqueID in_ObjectID,         ///
                 AkUInt32 in_uPropID,            ///
                 AkInt32& out_iValue             ///
                 );
  
             /// Get the value of a custom property of real type.
             /// \return AK_PartialSuccess if the object was found but no matching custom property was found on this object. Note that it could mean this value is the default value.
             AK_EXTERNAPIFUNC( AKRESULT, GetCustomPropertyValue )(
                 AkUniqueID in_ObjectID,         ///
                 AkUInt32 in_uPropID,            ///
                 AkReal32& out_fValue            ///
                 );
  
         } //namespace Query
     } //namespace SoundEngine
 } //namespace AK
  
 #endif // _AK_QUERYPARAMS_H_

AK::SoundEngine::Query::GetSwitch

AKSOUNDENGINE_API AKRESULT GetSwitch(AkSwitchGroupID in_switchGroup, AkGameObjectID in_gameObjectID, AkSwitchStateID &out_rSwitchState)

AkPositioningInfo::bEnableAttenuation

bool bEnableAttenuation

Attenuation parameter set is active.

Definition: AkQueryParameters.h:49

AK::SoundEngine::Query::RTPCValue_Last

@ RTPCValue_Last

End of enum, invalid value.

Definition: AkQueryParameters.h:167

AkObjectInfo::parentID

AkUniqueID parentID

Object ID of the parent

Definition: AkQueryParameters.h:70

AkSwitchGroupID

AkUInt32 AkSwitchGroupID

Switch group ID

Definition: AkTypedefs.h:50

AK::SoundEngine::Query::GameObjDst::GameObjDst

GameObjDst(AkGameObjectID in_gameObjID, AkReal32 in_dst)

Easy constructor

Definition: AkQueryParameters.h:454

Definition of data structures for AkAudioObject

Definition: AkWwiseSDKVersion.cs:31

AkAuxSendValue

Auxiliary bus sends information per game object per given auxiliary bus.

Definition: AkSoundEngineTypes.h:107

AK::SoundEngine::Query::RTPCValue_GameObject

@ RTPCValue_GameObject

The value is the game object specific RTPC.

Definition: AkQueryParameters.h:164

AK::SoundEngine::Query::GetObjectObstructionAndOcclusion

AKSOUNDENGINE_API AKRESULT GetObjectObstructionAndOcclusion(AkGameObjectID in_EmitterID, AkGameObjectID in_ListenerID, AkReal32 &out_rfObstructionLevel, AkReal32 &out_rfOcclusionLevel)

AK::SoundEngine::Query::GetListenerPosition

AKSOUNDENGINE_API AKRESULT GetListenerPosition(AkGameObjectID in_uListenerID, AkListenerPosition &out_rPosition)

AK::SoundEngine::Query::RTPCValue_Global

@ RTPCValue_Global

The value is the Global RTPC.

Definition: AkQueryParameters.h:163

AkLPFType

AkReal32 AkLPFType

Low-pass filter type

Definition: AkTypedefs.h:40

AkGameObjectID

AkUInt64 AkGameObjectID

Game object ID

Definition: AkTypedefs.h:39

AK_EXTERNAPIFUNC

#define AK_EXTERNAPIFUNC(_type, _name)

Definition: AkSoundEngineExport.h:81

AkChannelConfig

Definition: AkSpeakerConfig.h:436

AkPositioningInfo::fVolAuxGameDefAtMaxDist

AkReal32 fVolAuxGameDefAtMaxDist

Volume wet at maximum distance (if any) (based on the Game defined distance attenuation)

Definition: AkQueryParameters.h:60

AK::SoundEngine::Query::GetListenerSpatialization

AKSOUNDENGINE_API AKRESULT GetListenerSpatialization(AkGameObjectID in_uListenerID, bool &out_rbSpatialized, AK::SpeakerVolumes::VectorPtr &out_pVolumeOffsets, AkChannelConfig &out_channelConfig)

AkSpeakerPanningType

Speaker panning type: type of panning logic when object is not 3D spatialized (i.e....

Definition: AkEnums.h:222

AkPositioningInfo::fConeMaxAttenuation

AkReal32 fConeMaxAttenuation

Cone max attenuation

Definition: AkQueryParameters.h:54

AK_INVALID_GAME_OBJECT

static const AkGameObjectID AK_INVALID_GAME_OBJECT

Invalid game object (may also mean all game objects)

Definition: AkConstants.h:33

AkPositioningInfo::HPFValueAtMaxDist

AkLPFType HPFValueAtMaxDist

High pass filter value at max distance (if any)

Definition: AkQueryParameters.h:63

AK::SoundEngine::Query::GetPositioningInfo

AKSOUNDENGINE_API AKRESULT GetPositioningInfo(AkUniqueID in_ObjectID, AkPositioningInfo &out_rPositioningInfo)

AK::SoundEngine::Query::GetPlayingIDsFromGameObject

AKSOUNDENGINE_API AKRESULT GetPlayingIDsFromGameObject(AkGameObjectID in_GameObjId, AkUInt32 &io_ruNumIDs, AkPlayingID *out_aPlayingIDs)

AK::SoundEngine::Query::GetCustomPropertyValue

AKSOUNDENGINE_API AKRESULT GetCustomPropertyValue(AkUniqueID in_ObjectID, AkUInt32 in_uPropID, AkInt32 &out_iValue)

AkUniqueID

AkUInt32 AkUniqueID

Unique 32-bit ID

Definition: AkTypedefs.h:31

AK::SoundEngine::Query::GameObjDst

Definition: AkQueryParameters.h:446

AkPositioningInfo::fInnerAngle

AkReal32 fInnerAngle

Inner angle

Definition: AkQueryParameters.h:52

AkArray

Specific implementation of array

Definition: AkArray.h:260

AkPositioningInfo::fCenterPct

AkReal32 fCenterPct

Center % [0..1]

Definition: AkQueryParameters.h:44

AkReal32

float AkReal32

32-bit floating point

Definition: AkNumeralTypes.h:43

Ak3DPositionType

3D position type: defines what acts as the emitter position for computing spatialization against the ...

Definition: AkEnums.h:233

AkInt32

int32_t AkInt32

Signed 32-bit integer

Definition: AkNumeralTypes.h:40

Ak3DSpatializationMode

3D spatialization mode.

Definition: AkEnums.h:253

AK::SoundEngine::Query::RTPCValue_Default

@ RTPCValue_Default

The value is the Default RTPC.

Definition: AkQueryParameters.h:162

AkPositioningInfo::LPFCone

AkLPFType LPFCone

Cone low pass filter value

Definition: AkQueryParameters.h:55

AkPositioningInfo::fVolAuxUserDefAtMaxDist

AkReal32 fVolAuxUserDefAtMaxDist

Volume wet at maximum distance (if any) (based on the User defined distance attenuation)

Definition: AkQueryParameters.h:61

AK::SoundEngine::Query::GetMaxRadius

AKSOUNDENGINE_API AKRESULT GetMaxRadius(AkRadiusList &io_RadiusList)

AkStateGroupID

AkUInt32 AkStateGroupID

State group ID

Definition: AkTypedefs.h:33

AK::SoundEngine::Query::GameObjDst::GameObjDst

GameObjDst()

Default constructor

Definition: AkQueryParameters.h:448

AkPositioningInfo::bHoldEmitterPosAndOrient

bool bHoldEmitterPosAndOrient

Hold emitter position and orientation values when starting playback.

Definition: AkQueryParameters.h:47

AK::SoundEngine::Query::GetListeners

AKSOUNDENGINE_API AKRESULT GetListeners(AkGameObjectID in_GameObjectID, AkGameObjectID *out_ListenerObjectIDs, AkUInt32 &oi_uNumListeners)

AkSwitchStateID

AkUInt32 AkSwitchStateID

Switch ID

Definition: AkTypedefs.h:51

AK::SoundEngine::Query::GameObjDst::m_dst

AkReal32 m_dst

MaxDistance

Definition: AkQueryParameters.h:460

AK::SoundEngine::Query::GetGameObjectFromPlayingID

AKSOUNDENGINE_API AkGameObjectID GetGameObjectFromPlayingID(AkPlayingID in_playingID)

AkPositioningInfo::bUseConeAttenuation

bool bUseConeAttenuation

Use the cone attenuation

Definition: AkQueryParameters.h:51

AkObjectInfo::iDepth

AkInt32 iDepth

Depth in tree

Definition: AkQueryParameters.h:71

AkPositioningInfo::e3dPositioningType

Ak3DPositionType e3dPositioningType

3D position type: defines what acts as the emitter position for computing spatialization against the ...

Definition: AkQueryParameters.h:46

AkRtpcValue

AkReal32 AkRtpcValue

Real time parameter control value

Definition: AkTypedefs.h:53

AkArray.h

AkSoundEngineExport.h

AK::SoundEngine::Query::GetIsGameObjectActive

AKSOUNDENGINE_API bool GetIsGameObjectActive(AkGameObjectID in_GameObjId)

AK::SoundEngine::Query::GetState

AKSOUNDENGINE_API AKRESULT GetState(AkStateGroupID in_stateGroup, AkStateID &out_rState)

AK::SoundEngine::Query::RTPCValue_type

RTPCValue_type

Definition: AkQueryParameters.h:161

AK::SoundEngine::Query::GetActiveGameObjects

AKSOUNDENGINE_API AKRESULT GetActiveGameObjects(AkGameObjectsList &io_GameObjectList)

AkRtpcID

AkUInt32 AkRtpcID

Real time parameter control ID

Definition: AkTypedefs.h:52

AkPositioningInfo::pannerType

AkSpeakerPanningType pannerType

Speaker panning type: type of panning logic when object is not 3D spatialized.

Definition: AkQueryParameters.h:45

AkPositioningInfo

Positioning information obtained from an object

Definition: AkQueryParameters.h:43

AK::SoundEngine::Query::GameObjDst::m_gameObjID

AkGameObjectID m_gameObjID

Game object ID

Definition: AkQueryParameters.h:459

AkObjectInfo

Object information structure for QueryAudioObjectsIDs

Definition: AkQueryParameters.h:68

AKRESULT

Definition: AkEnums.h:32

AK::SoundEngine::Query::GetEventIDFromPlayingID

AKSOUNDENGINE_API AkUniqueID GetEventIDFromPlayingID(AkPlayingID in_playingID)

AkPositioningInfo::e3DSpatializationMode

Ak3DSpatializationMode e3DSpatializationMode

Spatialization mode

Definition: AkQueryParameters.h:48

AkStateID

AkUInt32 AkStateID

State ID

Definition: AkTypedefs.h:32

AkPositioningInfo::fMaxDistance

AkReal32 fMaxDistance

Maximum distance

Definition: AkQueryParameters.h:58

AK::SoundEngine::Query::RTPCValue_PlayingID

@ RTPCValue_PlayingID

The value is the playing ID specific RTPC.

Definition: AkQueryParameters.h:165

AkTypes.h

AK::SoundEngine::Query::QueryAudioObjectIDs

AKSOUNDENGINE_API AKRESULT QueryAudioObjectIDs(AkUniqueID in_eventID, AkUInt32 &io_ruNumItems, AkObjectInfo *out_aObjectInfos)

AK::SoundEngine::Query::AkGameObjectsList

AkArray AkGameObjectsList

Definition: AkQueryParameters.h:424

AkCommonDefs.h

AkUInt32

uint32_t AkUInt32

Unsigned 32-bit integer

Definition: AkNumeralTypes.h:35

AkPositioningInfo::HPFCone

AkLPFType HPFCone

Cone low pass filter value

Definition: AkQueryParameters.h:56

AkPositioningInfo::LPFValueAtMaxDist

AkLPFType LPFValueAtMaxDist

Low pass filter value at max distance (if any)

Definition: AkQueryParameters.h:62

AK::SoundEngine::Query::GetRTPCValue

AKSOUNDENGINE_API AKRESULT GetRTPCValue(AkRtpcID in_rtpcID, AkGameObjectID in_gameObjectID, AkPlayingID in_playingID, AkRtpcValue &out_rValue, RTPCValue_type &io_rValueType)

AkPositioningInfo::fVolDryAtMaxDist

AkReal32 fVolDryAtMaxDist

Volume dry at maximum distance

Definition: AkQueryParameters.h:59

AkObjectInfo::objID

AkUniqueID objID

Object ID

Definition: AkQueryParameters.h:69

AK::SoundEngine::Query::RTPCValue_Unavailable

@ RTPCValue_Unavailable

The value is not available for the RTPC specified.

Definition: AkQueryParameters.h:166

AkPositioningInfo::fOuterAngle

AkReal32 fOuterAngle

Outer angle

Definition: AkQueryParameters.h:53

AK::SpeakerVolumes::VectorPtr

AkSpeakerVolumesMatrixPtr VectorPtr

Definition: AkTypedefs.h:95

AkPlayingID

AkUInt32 AkPlayingID

A unique identifier generated whenever a PostEvent is called (or when a Dynamic Sequence is created)....

Definition: AkTypedefs.h:34

AK::SoundEngine::Query::GetGameObjectAuxSendValues

AKSOUNDENGINE_API AKRESULT GetGameObjectAuxSendValues(AkGameObjectID in_gameObjectID, AkAuxSendValue *out_paAuxSendValues, AkUInt32 &io_ruNumSendValues)

AK::SoundEngine::Query::AkRadiusList

AkArray AkRadiusList

Definition: AkQueryParameters.h:466

AK::SoundEngine::Query::GetPosition

AKSOUNDENGINE_API AKRESULT GetPosition(AkGameObjectID in_GameObjectID, AkSoundPosition &out_rPosition)

AK::SoundEngine::Query::GetGameObjectDryLevelValue

AKSOUNDENGINE_API AKRESULT GetGameObjectDryLevelValue(AkGameObjectID in_EmitterID, AkGameObjectID in_ListenerID, AkReal32 &out_rfControlValue)