_ak_spatial_audio_8h

Wwise SDK 2022.1.18

 /*******************************************************************************
 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) 2024 Audiokinetic Inc.
 *******************************************************************************/
  
 /// \file 
 /// Spatial Audio interface.
  
 #pragma once
  
 #include <AK/SpatialAudio/Common/AkSpatialAudioTypes.h>
 #include <AK/Plugin/AkReflectGameData.h>
 #include <AK/SoundEngine/Common/AkSoundEngine.h>
  
  
 /// Initialization settings of the spatial audio module.
 struct AkSpatialAudioInitSettings
 {
     AkSpatialAudioInitSettings()
         : uMaxSoundPropagationDepth(AK_MAX_SOUND_PROPAGATION_DEPTH)
         , fMovementThreshold(AK_DEFAULT_MOVEMENT_THRESHOLD)
         , uNumberOfPrimaryRays(100)
         , uMaxReflectionOrder(1)
         , uMaxDiffractionOrder(8)
         , uDiffractionOnReflectionsOrder(2)
         , fMaxPathLength(10000.0f)
         , fCPULimitPercentage(0.0f)
         , uLoadBalancingSpread(1)
         , bEnableGeometricDiffractionAndTransmission(true)
         , bCalcEmitterVirtualPosition(true)
         
     {}
  
     AkUInt32 uMaxSoundPropagationDepth;             ///< Maximum number of portals that sound can propagate through; must be less than or equal to AK_MAX_SOUND_PROPAGATION_DEPTH.
     AkReal32 fMovementThreshold;                    ///< Amount that an emitter or listener has to move to trigger a recalculation of reflections/diffraction. Larger values can reduce the CPU load at the cost of reduced accuracy.
     AkUInt32 uNumberOfPrimaryRays;                  ///< The number of primary rays used in the ray tracing engine. A larger number of rays will increase the chances of finding reflection and diffraction paths, but will result in higher CPU usage. When CPU limit is active (see \ref AkSpatialAudioInitSettings::fCPULimitPercentage), this setting represents the maximum allowed number of primary rays.
     AkUInt32 uMaxReflectionOrder;                   ///< Maximum reflection order [1, 4] - the number of 'bounces' in a reflection path. A high reflection order renders more details at the expense of higher CPU usage.
     AkUInt32 uMaxDiffractionOrder;                  ///< Maximum diffraction order [1, 8] - the number of 'bends' in a diffraction path. A high diffraction order accommodates more complex geometry at the expense of higher CPU usage.
                                                     ///< Diffraction must be enabled on the geometry to find diffraction paths (refer to \c AkGeometryParams). Set to 0 to disable diffraction on all geometry.
                                                     ///< This parameter limits the recursion depth of diffraction rays cast from the listener to scan the environment, and also the depth of the diffraction search to find paths between emitter and listener.
                                                     ///< To optimize CPU usage, set it to the maximum number of edges you expect the obstructing geometry to traverse. 
                                                     ///< For example, if box-shaped geometry is used exclusively, and only a single box is expected between an emitter and then listener, limiting \c uMaxDiffractionOrder to 2 may be sufficient.
                                                     ///< A diffraction path search starts from the listener, so when the maximum diffraction order is exceeded, the remaining geometry between the end of the path and the emitter is ignored. 
                                                     ///< In such case, where the search is terminated before reaching the emitter, the diffraction coefficient will be underestimated. It is calculated from a partial path, ignoring any remaining geometry.   
     AkUInt32 uDiffractionOnReflectionsOrder;        ///< The maximum possible number of diffraction points at each end of a reflection path. Diffraction on reflection allows reflections to fade in and out smoothly as the listener or emitter moves in and out of the reflection's shadow zone.
                                                     ///< When greater than zero, diffraction rays are sent from the listener to search for reflections around one or more corners from the listener.
                                                     ///< Diffraction must be enabled on the geometry to find diffracted reflections (refer to \c AkGeometryParams). Set to 0 to disable diffraction on reflections.
     AkReal32 fMaxPathLength;                        ///< The total length of a path composed of a sequence of segments (or rays) cannot exceed the defined maximum path length. High values compute longer paths but increase the CPU cost.
                                                     ///< Each individual sound is also affected by its maximum attenuation distance, specified in the Authoring tool. Reflection or diffraction paths, calculated inside Spatial Audio, will never exceed a sound's maximum attenuation distance.
                                                     ///< Note, however, that attenuation is considered infinite if the furthest point is above the audibility threshold.
     AkReal32 fCPULimitPercentage;                   ///< Defines the targeted computation time allocated for the ray tracing engine. Defined as a percentage [0, 100] of the current audio frame. The ray tracing engine dynamically adapts the number of primary rays to target the specified computation time value. In all circumstances, the computed number of primary rays cannot exceed the number of primary rays specified by AkSpatialAudioInitSettings::uNumberOfPrimaryRays.
                                                     ///< A value of 0 indicates no target has been set. In this case, the number of primary rays is fixed and is set by AkSpatialAudioInitSettings::uNumberOfPrimaryRays.
     AkUInt32 uLoadBalancingSpread;                  ///< Spread the computation of paths on uLoadBalancingSpread frames [1..[. When uLoadBalancingSpread is set to 1, no load balancing is done. Values greater than 1 indicate the computation of paths will be spread on this number of frames.
     bool bEnableGeometricDiffractionAndTransmission;///< Enable computation of geometric diffraction and transmission paths for all sources that have the <b>Enable Diffraction and Transmission</b> box checked in the Positioning tab of the Wwise Property Editor.
                                                     ///< This flag enables sound paths around (diffraction) and through (transmission) geometry (see \c AK::SpatialAudio::SetGeometry).
                                                     ///< Setting \c bEnableGeometricDiffractionAndTransmission to false implies that geometry is only to be used for reflection calculation.
                                                     ///< Diffraction edges must be enabled on geometry for diffraction calculation (see \c AkGeometryParams).
                                                     ///< If \c bEnableGeometricDiffractionAndTransmission is false but a sound has <b>Enable Diffraction and Transmission</b> selected in the Positioning tab of the authoring tool, the sound will diffract through portals but will pass through geometry as if it is not there.
                                                     ///< One would typically disable this setting in the case that the game intends to perform its own obstruction calculation, but geometry is still passed to spatial audio for reflection calculation.
     bool bCalcEmitterVirtualPosition;               ///< An emitter that is diffracted through a portal or around geometry will have its apparent or virtual position calculated by Wwise Spatial Audio and passed on to the sound engine.
 };
  
 // Settings for individual image sources.
 struct AkImageSourceSettings
 {
     AkImageSourceSettings() {}
  
     AkImageSourceSettings(AkVector64 in_sourcePosition, AkReal32 in_fDistanceScalingFactor, AkReal32 in_fLevel)
         : params(in_sourcePosition, in_fDistanceScalingFactor, in_fLevel)
         , texture()
     {
     }
  
     void SetOneTexture(AkUniqueID in_texture)
     {
         texture.uNumTexture = 1;
         texture.arTextureID[0] = in_texture;
     }
  
     /// Image source parameters.
     AkImageSourceParams params;
  
     /// Acoustic texture that goes with this image source.
     AkImageSourceTexture texture;
 };
  
 /// Vertex for a spatial audio mesh.
 struct AkVertex
 {
     /// Constructor
     AkVertex() : X(0.f), Y(0.f), Z(0.f) {}
     
     /// Constructor
     AkVertex(AkReal32 in_X, AkReal32 in_Y, AkReal32 in_Z) : X(in_X), Y(in_Y), Z(in_Z) {}
  
     AkReal32 X; ///< X coordinate
     AkReal32 Y; ///< Y coordinate
     AkReal32 Z; ///< Z coordinate
 };
  
 ///  AkExtent describes an extent with width, height and depth. halfWidth, halfHeight and halfDepth should form a vector from the centre of the volume to the positive corner.
 ///  For portals, negative values in the extent will cause an error. For rooms, negative values can be used to opt out of room transmission.
 struct AkExtent
 {
     AkExtent() {}
  
     AkExtent(AkReal32 in_halfWidth, AkReal32 in_halfHeight, AkReal32 in_halfDepth)
         : halfWidth(in_halfWidth)
         , halfHeight(in_halfHeight)
         , halfDepth(in_halfDepth)
     {}
     
     AkReal32 halfWidth = 0.0f;
     AkReal32 halfHeight = 0.0f;
     AkReal32 halfDepth = 0.0f;
 };
  
 /// Triangle for a spatial audio mesh. 
 struct AkTriangle
 {
     /// Constructor
     AkTriangle()    : point0(AK_INVALID_VERTEX)
                     , point1(AK_INVALID_VERTEX)
                     , point2(AK_INVALID_VERTEX)
                     , surface(AK_INVALID_SURFACE)
     {}
  
     /// Constructor
     AkTriangle(AkVertIdx in_pt0, AkVertIdx in_pt1, AkVertIdx in_pt2, AkSurfIdx in_surfaceInfo) 
         : point0(in_pt0)
         , point1(in_pt1)
         , point2(in_pt2)
         , surface(in_surfaceInfo)
     {}
  
     /// Index into the vertex table passed into \c AkGeometryParams that describes the first vertex of the triangle. Triangles are double-sided, so vertex order in not important.
     AkVertIdx point0; 
  
     /// Index into the vertex table passed into \c AkGeometryParams that describes the second vertex of the triangle. Triangles are double-sided, so vertex order in not important.
     AkVertIdx point1;
  
     /// Index into the vertex table passed into \c AkGeometryParams that describes the third vertex of the triangle. Triangles are double-sided, so vertex order in not important.
     AkVertIdx point2;
  
     /// Index into the surface table passed into \c AkGeometryParams that describes the surface properties of the triangle.  
     /// If this field is left as \c AK_INVALID_SURFACE, then a default-constructed \c AkAcousticSurface is used.
     AkSurfIdx surface;
 };
  
 /// Describes the acoustic surface properties of one or more triangles.
 /// An single acoustic surface may describe any number of triangles, depending on the granularity desired.  For example, if desired for debugging, one could create a unique 
 /// \c AkAcousticSurface struct for each triangle, and define a unique name for each.  Alternatively, a single \c AkAcousticSurface could be used to describe all triangles.
 /// In fact it is not necessary to define any acoustic surfaces at all.  If the \c AkTriangle::surface field is left as \c AK_INVALID_SURFACE, then a default-constructed \c AkAcousticSurface is used.
 struct AkAcousticSurface
 {
     /// Constructor
     AkAcousticSurface(): textureID(AK_INVALID_UNIQUE_ID)
                 , transmissionLoss(1.0f)
                 , strName(NULL)
     {}
  
     /// Acoustic texture ShareSet ID for the surface.  The acoustic texture is authored in Wwise, and the shareset ID may be obtained by calling \c AK::SoundEngine::GetIDFromString
     /// \sa <tt>\ref AK::SoundEngine::GetIDFromString()</tt>
     AkUInt32 textureID;
  
     /// Value to set when modeling sound transmission through geometry. Transmission is modeled only when the sound emitted enables diffraction and there is no direct line of sight from the emitter to the listener.
     /// If more that one surface is between the emitter and the listener, the maximum of each surface's transmission loss value is used. If the emitter and listener are in different rooms, then the rooms' transmission loss is taken into account.
     /// The maximum of all the surfaces' transmission loss value, and the transmission loss value (see \c AkRoomParams) is used to render the transmission path.
     /// Valid range: (0.f-1.f)
     /// - \ref AkRoomParams
     AkReal32 transmissionLoss;
  
     /// Name to describe this surface
     const char* strName;
 };
  
 /// Structure for retrieving information about the indirect paths of a sound that have been calculated via the geometric reflections API. Useful for debug draw applications.
 struct AkReflectionPathInfo
 {
     /// Apparent source of the reflected sound that follows this path.
     AkVector64 imageSource;
     
     /// Vertices of the indirect path.
     /// pathPoint[0] is closest to the emitter, pathPoint[numPathPoints-1] is closest to the listener.
     AkVector64 pathPoint[AK_MAX_REFLECTION_PATH_LENGTH];
  
     /// The surfaces that were hit in the path.
     /// surfaces[0] is closest to the emitter, surfaces[numPathPoints-1] is closest to the listener.
     AkAcousticSurface surfaces[AK_MAX_REFLECTION_PATH_LENGTH];
  
     /// Number of valid elements in the \c pathPoint[], \c surfaces[], and \c diffraction[] arrays.
     AkUInt32 numPathPoints;
  
     /// Number of reflections in the \c pathPoint[] array. Shadow zone diffraction does not count as a reflection. If there is no shadow zone diffraction, \c numReflections is equal to \c numPathPoints.
     AkUInt32 numReflections;
  
     /// Diffraction amount, normalized to the range [0,1]
     AkReal32 diffraction[AK_MAX_REFLECTION_PATH_LENGTH];
     
     /// Linear gain applied to image source.
     AkReal32 level;
  
     /// Deprecated - always false. Occluded paths are not generated.
     bool isOccluded;
 };
  
 /// Structure for retrieving information about paths for a given emitter. 
 /// The diffraction paths represent indirect sound paths from the emitter to the listener, whether they go through portals 
 /// (via the rooms and portals API) or are diffracted around edges (via the geometric diffraction API).
 /// The direct path is included here and can be identified by checking \c nodeCount == 0. The direct path may have a non-zero transmission loss 
 /// if it passes through geometry or between rooms.
 struct AkDiffractionPathInfo
 {
     /// Defines the maximum number of nodes that a user can retrieve information about.  Longer paths will be truncated. 
     static const AkUInt32 kMaxNodes = AK_MAX_SOUND_PROPAGATION_DEPTH;
  
     /// Diffraction points along the path. nodes[0] is the point closest to the listener; nodes[numNodes-1] is the point closest to the emitter. 
     /// Neither the emitter position nor the listener position are represented in this array.
     AkVector64 nodes[kMaxNodes];
  
     /// Emitter position. This is the source position for an emitter. In all cases, except for radial emitters, it is the same position as the game object position.
     /// For radial emitters, it is the calculated position at the edge of the volume.
     AkVector64 emitterPos;
  
     /// Raw diffraction angles at each point, in radians.
     AkReal32 angles[kMaxNodes];
  
     /// ID of the portals that the path passes through.  For a given node at position i (in the nodes array), if the path diffracts on a geometric edge, then portals[i] will be an invalid portal ID (ie. portals[i].IsValid() will return false). 
     /// Otherwise, if the path diffracts through a portal at position i, then portals[i] will be the ID of that portal.
     /// portal[0] represents the node closest to the listener; portal[numNodes-1] represents the node closest to the emitter.
     AkPortalID portals[kMaxNodes];
  
     /// ID's of the rooms that the path passes through. For a given node at position i, room[i] is the room on the listener's side of the node. If node i diffracts through a portal, 
     /// then rooms[i] is on the listener's side of the portal, and rooms[i+1] is on the emitters side of the portal.
     /// There is always one extra slot for a room so that the emitters room is always returned in slot room[numNodes] (assuming the path has not been truncated).
     AkRoomID rooms[kMaxNodes + 1];
  
     /// Virtual emitter position. This is the position that is passed to the sound engine to render the audio using multi-positioning, for this particular path.
     AkWorldTransform virtualPos;
  
     /// Total number of nodes in the path.  Defines the number of valid entries in the \c nodes, \c angles, and \c portals arrays. The \c rooms array has one extra slot to fit the emitter's room.
     AkUInt32 nodeCount;
  
     /// Calculated total diffraction from this path, normalized to the range [0,1]
     /// The diffraction amount is calculated from the sum of the deviation angles from a straight line, of all angles at each nodePoint. 
     //  Can be thought of as how far into the 'shadow region' the sound has to 'bend' to reach the listener.
     /// This value is applied internally, by spatial audio, as the Diffraction value and built-in parameter of the emitter game object.
     /// \sa
     /// - \ref AkSpatialAudioInitSettings
     AkReal32 diffraction;
  
     /// Calculated total transmission loss from this path, normalized to the range [0,1]
     /// This field will be 0 for diffraction paths where \c nodeCount > 0. It may be non-zero for the direct path where \c nodeCount == 0.
     /// The path's transmission loss value is the combination of the geometric transmission loss and the room transmission loss, by taking the greater of the two.
     /// The geometric transmission loss is calculated from the transmission loss values assigned to the geometry that this path transmits through.
     /// If a path transmits through multiple geometries with different transmission loss values, the largest value is taken.
     /// The room transmission loss is taken from the emitter and listener rooms' transmission loss values, and likewise, 
     /// if the listener's room and the emitter's room have different transmission loss values, the greater of the two is used.
     /// This value is applied internally, by spatial audio, as the Transmission Loss value and built-in parameter of the emitter game object.
     /// \sa
     /// - \ref AkSpatialAudioInitSettings
     /// - \ref AkRoomParams
     /// - \ref AkAcousticSurface
     AkReal32 transmissionLoss;
  
     /// Total path length
     /// Represents the sum of the length of the individual segments between nodes, with a correction factor applied for diffraction. 
     /// The correction factor simulates the phenomenon where by diffracted sound waves decay faster than incident sound waves and can be customized in the spatial audio init settings.
     /// \sa
     /// - \ref AkSpatialAudioInitSettings
     AkReal32 totLength;
  
     /// Obstruction value for this path 
     /// This value includes the accumulated portal obstruction for all portals along the path.
     AkReal32 obstructionValue;
 };
  
 /// Parameters passed to \c SetPortal
 struct AkPortalParams
 {
     /// Constructor
     AkPortalParams() :
         bEnabled(false)
     {}
  
     /// Portal's position and orientation in the 3D world. 
     /// Position vector is the center of the opening.
     /// OrientationFront vector must be unit-length and point along the normal of the portal, and must be orthogonal to Up. It defines the local positive-Z dimension (depth/transition axis) of the portal, used by Extent. 
     /// OrientationTop vector must be unit-length and point along the top of the portal (tangent to the wall), must be orthogonal to Front. It defines the local positive-Y direction (height) of the portal, used by Extent.
     AkWorldTransform                Transform;
  
     /// Portal extent. Defines the dimensions of the portal relative to its center; all components must be positive numbers. The local right and up dimensions are used in diffraction calculations, 
     /// whereas the front dimension defines a depth value which is used to implement smooth transitions between rooms. It is recommended that users experiment with different portal depths to find a value 
     /// that results in appropriately smooth transitions between rooms. Extent dimensions must be positive.
     AkExtent                        Extent;
  
     /// Whether or not the portal is active/enabled. For example, this parameter may be used to simulate open/closed doors.
     /// Portal diffraction is simulated when at least one portal exists and is active between an emitter and the listener.
     bool                            bEnabled;
  
     /// ID of the room to which the portal connects, in the direction of the Front vector.  If a room with this ID has not been added via AK::SpatialAudio::SetRoom,
     /// a room will be created with this ID and with default AkRoomParams.  If you would later like to update the AkRoomParams, simply call AK::SpatialAudio::SetRoom again with this same ID.
     /// - \ref AK::SpatialAudio::SetRoom
     /// - \ref AK::SpatialAudio::RemoveRoom
     /// - \ref AkRoomParams
     AkRoomID FrontRoom;
  
     /// ID of the room to which the portal connects, in the direction opposite to the Front vector. If a room with this ID has not been added via AK::SpatialAudio::SetRoom,
     /// a room will be created with this ID and with default AkRoomParams.  If you would later like to update the AkRoomParams, simply call AK::SpatialAudio::SetRoom again with this same ID.
     /// - \ref AK::SpatialAudio::SetRoom
     /// - \ref AK::SpatialAudio::RemoveRoom
     /// - \ref AkRoomParams
     AkRoomID BackRoom;
 };
  
 /// Parameters passed to \c SetRoom
 struct AkRoomParams
 {
     /// Constructor
     AkRoomParams() :  ReverbAuxBus(AK_INVALID_AUX_ID)
                     , ReverbLevel(1.f)
                     , TransmissionLoss(1.f)
                     , RoomGameObj_AuxSendLevelToSelf(0.f)
                     , RoomGameObj_KeepRegistered(false)
     {
         // default invalid values
         Up.X = 0.f;
         Up.Y = 1.f;
         Up.Z = 0.f;
         Front.X = 0.f;
         Front.Y = 0.f;
         Front.Z = 1.f;
     }
  
     /// Room Orientation. Up and Front must be orthonormal.
     /// Room orientation has an effect when the associated aux bus (see ReverbAuxBus) is set with 3D Spatialization in Wwise, as 3D Spatialization implements relative rotation of the emitter (room) and listener.
     AkVector Front;
  
     /// Room Orientation. Up and Front must be orthonormal.
     /// Room orientation has an effect when the associated aux bus (see ReverbAuxBus) is set with 3D Spatialization in Wwise, as 3D Spatialization implements relative rotation of the emitter (room) and listener.
     AkVector Up;
  
     /// The reverb aux bus that is associated with this room.  
     /// When Spatial Audio is told that a game object is in a particular room via SetGameObjectInRoom, a send to this aux bus will be created to model the reverb of the room.
     /// Using a combination of Rooms and Portals, Spatial Audio manages which game object the aux bus is spawned on, and what control gain is sent to the bus.  
     /// When a game object is inside a connected portal, as defined by the portal's orientation and extent vectors, both this aux send and the aux send of the adjacent room are active.
     /// Spatial audio modulates the control value for each send based on the game object's position, in relation to the portal's z-azis and extent, to crossfade the reverb between the two rooms.
     /// If more advanced control of reverb is desired, SetGameObjectAuxSendValues can be used to add additional sends on to a game object.
     /// - \ref AK::SpatialAudio::SetGameObjectInRoom
     /// - \ref AK::SoundEngine::SetGameObjectAuxSendValues
     AkAuxBusID                      ReverbAuxBus;
  
     /// The reverb control value for the send to ReverbAuxBus. Valid range: (0.f-1.f)
     /// Can be used to implement multiple rooms that share the same aux bus, but have different reverb levels.
     AkReal32                        ReverbLevel;
  
     /// Level to set when modeling transmission through walls. Transmission is modeled only when the sound emitted enables diffraction and there is no direct line of sight from the emitter to the listener.
     /// This transmission loss value is only applied when the listener and the emitter are in different rooms; it is taken as the maximum between the emitter's room's transmission loss value and the listener's room's transmission loss value.
     /// If there is geometry in between the listener and the emitter, then the transmission loss value assigned to surfaces hit by the ray between the emitter and listener is also taken into account.
     /// The maximum of all the surfaces' transmission loss value (see \c AkAcousticSurface), and the room's transmission loss value is used to render the transmission path.
     /// Valid range: (0.f-1.f)
     /// - \ref AkAcousticSurface
     AkReal32                        TransmissionLoss;
  
     /// Send level for sounds that are posted on the room game object; adds reverb to ambience and room tones. Valid range: (0.f-1.f).  Set to a value greater than 0 to have spatial audio create a send on the room game object, 
     /// where the room game object itself is specified as the listener and ReverbAuxBus is specified as the aux bus. A value of 0 disables the aux send. This should not be confused with ReverbLevel, which is the send level 
     /// for spatial audio emitters sending to the room game object.
     /// \aknote The room game object can be accessed though the ID that is passed to \c SetRoom() and the \c AkRoomID::AsGameObjectID() method.  Posting an event on the room game object leverages automatic room game object placement 
     /// by spatial audio so that when the listener is inside the room, the sound comes from all around the listener, and when the listener is outside the room, the sound comes from the portal(s). Typically, this would be used for
     /// surround ambiance beds or room tones. Point source sounds should use separate game objects that are registered as spatial audio emitters.
     /// \sa
     /// - \ref AkRoomParams::RoomGameObj_KeepRegistered
     /// - \ref AkRoomID
     AkReal32                        RoomGameObj_AuxSendLevelToSelf;
  
     /// If set to true, the room game object is registered on calling \c SetRoom(), and not released until the room is deleted or removed with \c RemoveRoom(). If set to false, Spatial Audio registers
     /// the room object only when it is needed by the sound propagation system for the purposes of reverb, and unregisters the game object when all reverb tails are finished.
     /// We recommend that you set RoomGameObj_KeepRegistered to true if you use RTPCs on the room game object, if you call \c SetScalingFactor(), or call \c PostEvent() for the purpose of ambience or room tones.
     /// \aknote The room game object can be accessed through the ID that is passed to \c SetRoom() and the \c AkRoomID::AsGameObjectID() method. Posting an event on the room game object uses automatic room game object placement 
     /// by Spatial Audio so that when the listener is inside the room, the sound comes from all around the listener, and when the listener is outside the room, the sound comes from the portal(s). Typically, this would be used for
     /// surround ambience beds or room tones. For point source sounds, use separate game objects that are registered as Spatial Audio emitters.
     /// \sa
     /// - \ref AkRoomParams::RoomGameObj_AuxSendLevelToSelf
     /// - \ref AkRoomID
     bool                            RoomGameObj_KeepRegistered;
  
     /// Associate this room with the geometry instance \c GeometryInstanceID, describing the shape of the room. When a room is associated with a geometry instance, the vertices are used to compute the spread value for room transmission.
     /// The vertices are used for computing an oriented bounding box for the room where the orientation of the bounding box is given by the Up and Front vectors. The center of the room is defined as the oriented bounding box center.
     /// The extent of the bounding box is computed from the geometry set's vertices projected on to the orientation axes.
     /// \aknote If the geometry set is only to be used for the room and not for reflection and diffraction calculation, then make sure to set \c AkGeometryParams::EnableTriangles to false. 
     /// It will still be necessary to create an instance for the geometry, so that the vertices can be positioned, scaled and rotated as desired.
     /// \sa
     /// - \ref spatial_audio_roomsportals_apiconfigroomgeometry
     /// - \ref AkGeometryParams
     AkGeometrySetID                 GeometryInstanceID;
 };
  
 /// Parameters passed to \c SetGeometry
 struct AkGeometryParams
 {
     /// Constructor
     AkGeometryParams() : Triangles(NULL), NumTriangles(0), Vertices(NULL), NumVertices(0), Surfaces(NULL), NumSurfaces(0), EnableDiffraction(false), EnableDiffractionOnBoundaryEdges(false), EnableTriangles(true) {}
  
     /// Pointer to an array of AkTriangle structures. 
     /// This array will be copied into spatial audio memory and will not be accessed after \c SetGeometry returns.
     /// - \ref AkTriangle
     /// - \ref AK::SpatialAudio::SetGeometry
     /// - \ref AK::SpatialAudio::RemoveGeometry
     AkTriangle* Triangles;
  
     /// Number of triangles in Triangles.
     AkTriIdx NumTriangles;          
  
     /// Pointer to an array of AkVertex structures. 
     /// This array will be copied into spatial audio memory and will not be accessed after \c SetGeometry returns.
     /// - \ref AkVertex
     /// - \ref AK::SpatialAudio::SetGeometry
     /// - \ref AK::SpatialAudio::RemoveGeometry
     AkVertex* Vertices;
  
     ///< Number of vertices in Vertices.
     AkVertIdx NumVertices;          
     
     ///< Pointer to an array of AkAcousticSurface structures.
     /// This array will be copied into spatial audio memory and will not be accessed after \c SetGeometry returns.
     /// - \ref AkVertex
     /// - \ref AK::SpatialAudio::SetGeometry
     /// - \ref AK::SpatialAudio::RemoveGeometry
     AkAcousticSurface* Surfaces;
  
     /// Number of of AkTriangleInfo structures in in_pTriangleInfo and number of AkTriIdx's in in_infoMap.
     AkSurfIdx NumSurfaces;
  
     /// Switch to enable or disable geometric diffraction for this Geometry.
     bool EnableDiffraction;
     
     /// Switch to enable or disable geometric diffraction on boundary edges for this Geometry.  Boundary edges are edges that are connected to only one triangle.
     bool EnableDiffractionOnBoundaryEdges;
  
     /// Switch to enable or disable the use of the triangles for this Geometry. When enabled, the geometry triangles are indexed for ray computation and used to computed reflection and diffraction.
     /// Set EnableTriangles to false when using a geometry set only to describe a room, and not for reflection and diffraction calculation.
     /// \sa
     /// - \ref AkRoomParams
     bool EnableTriangles;
 };
  
 #define AK_DEFAULT_GEOMETRY_POSITION_X (0.0)
 #define AK_DEFAULT_GEOMETRY_POSITION_Y (0.0)
 #define AK_DEFAULT_GEOMETRY_POSITION_Z (0.0)
 #define AK_DEFAULT_GEOMETRY_FRONT_X (0.0)
 #define AK_DEFAULT_GEOMETRY_FRONT_Y (0.0)
 #define AK_DEFAULT_GEOMETRY_FRONT_Z (1.0)
 #define AK_DEFAULT_GEOMETRY_TOP_X (0.0)
 #define AK_DEFAULT_GEOMETRY_TOP_Y (1.0)
 #define AK_DEFAULT_GEOMETRY_TOP_Z (0.0)
  
 /// Parameters passed to \c SetGeometryInstance
 struct AkGeometryInstanceParams
 {
     /// Constructor
     /// Creates an instance with an identity transform.
     /// \akwarning A default-constructed AkGeometryInstanceParams assumes the default floor plane is passed to AkInitSettings::eFloorPlane.
     AkGeometryInstanceParams() 
         : Scale({ 1, 1, 1 })
     {
         PositionAndOrientation.Set(
             AK_DEFAULT_GEOMETRY_POSITION_X, AK_DEFAULT_GEOMETRY_POSITION_Y, AK_DEFAULT_GEOMETRY_POSITION_Z,
             AK_DEFAULT_GEOMETRY_FRONT_X, AK_DEFAULT_GEOMETRY_FRONT_Y, AK_DEFAULT_GEOMETRY_FRONT_Z,
             AK_DEFAULT_GEOMETRY_TOP_X, AK_DEFAULT_GEOMETRY_TOP_Y, AK_DEFAULT_GEOMETRY_TOP_Z);
     }
  
     /// Set the position and orientation of the geometry instance.
     /// AkWorldTransform uses one vector to define the position of the geometry instance, and two more to define the orientation; a forward vector and an up vector. 
     /// To ensure that a geometry instance has the correct rotation with respect to the game, AkInitSettings::eFloorPlane must be initialized with the correct value.
     /// \sa
     /// - \ref AkInitSettings::eFloorPlane
     /// - \ref AK::SpatialAudio::SetGeometryInstance
     /// - \ref AK::SpatialAudio::RemoveGeometryInstance
     AkWorldTransform PositionAndOrientation;
  
     /// Set the 3-dimensional scaling of the geometry instance.
     /// \sa
     /// - \ref AK::SpatialAudio::SetGeometryInstance
     /// - \ref AK::SpatialAudio::RemoveGeometryInstance
     AkVector Scale;
  
     /// Geometry set referenced by the instance
     /// \sa
     /// - \ref AK::SpatialAudio::SetGeometry
     /// - \ref AK::SpatialAudio::RemoveGeometry
     /// - \ref AK::SpatialAudio::SetGeometryInstance
     /// - \ref AK::SpatialAudio::RemoveGeometryInstance
     AkGeometrySetID GeometrySetID;
  
     /// Associate this geometry instance with the room \c RoomID. Associating a geometry instance with a particular room will limit the scope in which the geometry is visible/accessible. \c RoomID can be left as default (-1), in which case 
     /// this geometry instance will have a global scope. It is recommended to associate geometry with a room when the geometry is (1) fully contained within the room (ie. not visible to other rooms accept by portals), 
     /// and (2) the room does not share geometry with other rooms. Doing so reduces the search space for ray casting performed by reflection and diffraction calculations. Take note that once one or more geometry instances 
     /// are associated with a room, that room will no longer be able to access geometry that is in the global scope.
     /// - \ref AK::SpatialAudio::SetRoom
     /// - \ref AkRoomParams
     AkRoomID RoomID;
 };
  
 /// Audiokinetic namespace
 namespace AK
 {
     /// Audiokinetic spatial audio namespace
     namespace SpatialAudio
     {
         ////////////////////////////////////////////////////////////////////////
         /// @name Basic functions. 
         /// In order to use SpatialAudio, you need to initalize it using Init, and register the listeners that you plan on using with any of the services offered by SpatialAudio, using 
         /// RegisterListener respectively, _after_ having registered their corresponding game object to the sound engine.
         /// \akwarning At the moment, there can be only one Spatial Audio listener registered at any given time.
         //@{
  
         /// Initialize the SpatialAudio API.  
         AK_EXTERNAPIFUNC(AKRESULT, Init)(const AkSpatialAudioInitSettings& in_initSettings);
  
         /// Assign a game object as the Spatial Audio listener.  There can be only one Spatial Audio listener registered at any given time; in_gameObjectID will replace any previously set Spatial Audio listener.
         /// The game object passed in must be registered by the client, at some point, for sound to be heard.  It is not necessary to be registered at the time of calling this function.
         /// If not listener is explicitly registered to spatial audio, then a default listener (set via \c AK::SoundEngine::SetDefaultListeners()) is selected.  If the are no default listeners, or there are more than one
         /// default listeners, then it is necessary to call RegisterListener() to specify which listener to use with Spatial Audio.
         AK_EXTERNAPIFUNC(AKRESULT, RegisterListener)(
             AkGameObjectID in_gameObjectID              ///< Game object ID
             );
  
         /// Unregister a game object as a listener in the SpatialAudio API; clean up Spatial Audio listener data associated with in_gameObjectID.  
         /// If in_gameObjectID is the current registered listener, calling this function will clear the Spatial Audio listener and
         /// Spatial Audio features will be disabled until another listener is registered.
         /// This function is optional - listener are automatically unregistered when their game object is deleted in the sound engine.
         /// \sa 
         /// - \ref AK::SpatialAudio::RegisterListener
         AK_EXTERNAPIFUNC(AKRESULT, UnregisterListener)(
             AkGameObjectID in_gameObjectID              ///< Game object ID
             );
  
         /// Define an inner and outer radius around each sound position for a specified game object.
         /// If the radii are set to 0, the game object is a point source. Non-zero radii create a Radial Emitter.
         /// The radii are used in spread and distance calculations that simulates sound emitting from a spherical volume of space.
         /// When applying attenuation curves, the distance between the listener and the inner sphere (defined by the sound position and \c in_innerRadius) is used. 
         /// The spread for each sound position is calculated as follows:
         /// - If the listener is outside the outer radius, the spread is defined by the area that the sphere occupies in the listener field of view. Specifically, this angle is calculated as 2.0*asinf( \c in_outerRadius / distance ), where distance is the distance between the listener and the sound position.
         /// - When the listener intersects the outer radius (the listener is exactly \c in_outerRadius units away from the sound position), the spread is exactly 50%.
         /// - When the listener is between the inner and outer radii, the spread interpolates linearly from 50% to 100% as the listener transitions from the outer radius towards the inner radius.
         /// - If the listener is inside the inner radius, the spread is 100%.
         /// \aknote Transmission and diffraction calculations in Spatial Audio always use the center of the sphere (the position(s) passed into \c AK::SoundEngine::SetPosition or \c AK::SoundEngine::SetMultiplePositions) for raycasting. 
         /// To obtain accurate diffraction and transmission calculations for radial sources, where different parts of the volume may take different paths through or around geometry,
         /// it is necessary to pass multiple sound positions into \c AK::SoundEngine::SetMultiplePositions to allow the engine to 'sample' the area at different points.
         /// - \ref AK::SoundEngine::SetPosition
         /// - \ref AK::SoundEngine::SetMultiplePositions
         AK_EXTERNAPIFUNC(AKRESULT, SetGameObjectRadius)(
             AkGameObjectID in_gameObjectID,             ///< Game object ID
             AkReal32 in_outerRadius,                    ///< Outer radius around each sound position, defining 50% spread. Must satisfy \c in_innerRadius <= \c in outerRadius.
             AkReal32 in_innerRadius                     ///< Inner radius around each sound position, defining 100% spread and 0 attenuation distance. Must satisfy \c in_innerRadius <= \c in outerRadius.
             );
  
         //@}
  
         ////////////////////////////////////////////////////////////////////////
         /// @name Helper functions for passing game data to the Reflect plug-in. 
         /// Use this API for detailed placement of reflection image sources.
         /// \aknote These functions are low-level and useful when your game engine already implements a geometrical approach to sound propagation such as an image-source or a ray tracing algorithm.
         /// Functions of Geometry are preferred and easier to use with the Reflect plug-in. \endaknote
         //@{
  
         /// Add or update an individual image source for processing via the AkReflect plug-in.  Use this API for detailed placement of
         /// reflection image sources, whose positions have been determined by the client, such as from the results of a ray cast, computation or by manual placement.  One possible
         /// use case is generating reflections that originate far enough away that they can be modeled as a static point source, for example, off of a distant mountain.
         /// The SpatialAudio API manages image sources added via SetImageSource() and sends them to the AkReflect plug-in that is on the aux bus with ID \c in_AuxBusID. 
         /// The image source applies all game objects that have a reflections aux send defined in the authoring tool, or only to a specific game object if \c in_gameObjectID is used.
         /// \aknote The \c AkImageSourceSettings struct passed in \c in_info must contain a unique image source ID to be able to identify this image source across frames and when updating and/or removing it later.  
         /// Each instance of AkReflect has its own set of data, so you may reuse ID, if desired, as long as \c in_gameObjectID and \c in_AuxBusID are different.
         /// \aknote It is possible for the AkReflect plugin to process reflections from both \c SetImageSource and the geometric reflections API on the same aux bus and game object, but be aware that image source ID collisions are possible.
         /// The image source IDs used by the geometric reflections API are generated from hashed data that uniquely identifies the reflecting surfaces. If a collision occurs, one of the reflections will not be heard.
         /// While collision are rare, to ensure that it never occurs use an aux bus for \c SetImageSource that is unique from the aux bus(es) defined in the authoring tool, and from those passed to \c SetEarlyReflectionsAuxSend.
         /// \endaknote
         /// \aknote For proper operation with AkReflect and the SpatialAudio API, any aux bus using AkReflect should have 'Listener Relative Routing' checked and the 3D Spatialization set to None in the Wwise authoring tool. See \ref spatial_audio_wwiseprojectsetup_businstances for more details. \endaknote
         /// \sa 
         /// - \ref AK::SpatialAudio::RemoveImageSource
         /// - \ref AK::SpatialAudio::ClearImageSources
         /// - \ref AK::SpatialAudio::SetGameObjectInRoom
         /// - \ref AK::SpatialAudio::SetEarlyReflectionsAuxSend
         AK_EXTERNAPIFUNC(AKRESULT, SetImageSource)(
             AkImageSourceID in_srcID,                               ///< The ID of the image source being added.
             const AkImageSourceSettings& in_info,                   ///< Image source information.
             const char* in_name,                                    ///< Name given to image source, can be used to identify the image source in the AK Reflect plugin UI.
             AkUniqueID in_AuxBusID = AK_INVALID_AUX_ID,             ///< Aux bus that has the AkReflect plug in for early reflection DSP. 
                                                                     ///< Pass AK_INVALID_AUX_ID to use the reflections aux bus defined in the authoring tool.
             AkGameObjectID in_gameObjectID = AK_INVALID_GAME_OBJECT ///< The ID of the emitter game object to which the image source applies. 
                                                                     ///< Pass AK_INVALID_GAME_OBJECT to apply to all game objects that have a reflections aux bus assigned in the authoring tool.
         );
  
         /// Remove an individual reflection image source that was previously added via \c SetImageSource.
         /// \sa 
         /// - \ref AK::SpatialAudio::SetImageSource
         /// - \ref AK::SpatialAudio::ClearImageSources
         AK_EXTERNAPIFUNC(AKRESULT, RemoveImageSource)(
             AkImageSourceID in_srcID,                                   ///< The ID of the image source to remove.
             AkUniqueID in_AuxBusID = AK_INVALID_AUX_ID,                 ///< Aux bus that was passed to SetImageSource.
             AkGameObjectID in_gameObjectID = AK_INVALID_GAME_OBJECT     ///< Game object ID that was passed to SetImageSource.
         );
  
         /// Remove all image sources matching \c in_AuxBusID and \c in_gameObjectID that were previously added via \c SetImageSource.
         /// Both \c in_AuxBusID and \c in_gameObjectID can be treated as wild cards matching all aux buses and/or all game object, by passing \c AK_INVALID_AUX_ID and/or \c AK_INVALID_GAME_OBJECT, respectively.
         /// \sa 
         /// - \ref AK::SpatialAudio::SetImageSource
         /// - \ref AK::SpatialAudio::RemoveImageSource
         AK_EXTERNAPIFUNC(AKRESULT, ClearImageSources)(
             AkUniqueID in_AuxBusID = AK_INVALID_AUX_ID,                         ///< Aux bus that was passed to SetImageSource, or AK_INVALID_AUX_ID to match all aux buses.
             AkGameObjectID in_gameObjectID = AK_INVALID_GAME_OBJECT             ///< Game object ID that was passed to SetImageSource, or AK_INVALID_GAME_OBJECT to match all game objects.
             );
  
         //@}
  
         ////////////////////////////////////////////////////////////////////////
         /// @name Geometry 
         /// Geometry API for early reflection processing using Reflect.
         //@{
  
         /// Add or update a set of geometry from the \c SpatialAudio module for geometric reflection and diffraction processing. A geometry set is a logical set of vertices, triangles, and acoustic surfaces,
         /// which are referenced by the same \c AkGeometrySetID. The ID (\c in_GeomSetID) must be unique and is also chosen by the client in a manner similar to \c AkGameObjectID's.
         /// It is necessary to create at least one geometry instance for each geometry set that is to be used for diffraction and reflection simulation.
         /// \sa 
         /// - \ref AkGeometryParams
         /// - \ref AK::SpatialAudio::SetGeometryInstance
         /// - \ref AK::SpatialAudio::RemoveGeometry
         AK_EXTERNAPIFUNC(AKRESULT, SetGeometry)(
             AkGeometrySetID in_GeomSetID,       ///< Unique geometry set ID, chosen by client.
             const AkGeometryParams& in_params   ///< Geometry parameters to set.
         );
         
         /// Remove a set of geometry to the SpatialAudio API.
         /// Calling \c AK::SpatialAudio::RemoveGeometry will remove all instances of the geometry from the scene.
         /// \sa 
         /// - \ref AK::SpatialAudio::SetGeometry
         AK_EXTERNAPIFUNC(AKRESULT, RemoveGeometry)(
             AkGeometrySetID in_SetID        ///< ID of geometry set to be removed.
         );
  
         /// Add or update a geometry instance from the \c SpatialAudio module for geometric reflection and diffraction processing. 
         /// A geometry instance is a unique instance of a geometry set with a specified transform (position, rotation and scale). 
         /// It is necessary to create at least one geometry instance for each geometry set that is to be used for diffraction and reflection simulation.
         /// The ID (\c in_GeomSetInstanceID) must be unique amongst all geometry instances, including geometry instances referencing different geometry sets. The ID is chosen by the client in a manner similar to \c AkGameObjectID's.
         /// To update the transform of an existing geometry instance, call SetGeometryInstance again, passing the same \c AkGeometryInstanceID, with the updated transform. 
         /// \sa 
         /// - \ref AkGeometryInstanceParams
         /// - \ref AK::SpatialAudio::RemoveGeometryInstance
         AK_EXTERNAPIFUNC(AKRESULT, SetGeometryInstance)(
             AkGeometryInstanceID in_GeometryInstanceID, ///< Unique geometry set instance ID, chosen by client.
             const AkGeometryInstanceParams& in_params   ///< Geometry instance parameters to set.
             );
  
         /// Remove a geometry instance from the SpatialAudio API.
         /// \sa 
         /// - \ref AK::SpatialAudio::SetGeometryInstance
         AK_EXTERNAPIFUNC(AKRESULT, RemoveGeometryInstance)(
             AkGeometryInstanceID in_GeometryInstanceID  ///< ID of geometry set instance to be removed.
             );
  
         /// Query information about the reflection paths that have been calculated via geometric reflection processing in the SpatialAudio API. This function can be used for debugging purposes.
         /// This function must acquire the global sound engine lock and therefore, may block waiting for the lock.
         /// \sa
         /// - \ref AkReflectionPathInfo
         AK_EXTERNAPIFUNC(AKRESULT, QueryReflectionPaths)(
             AkGameObjectID in_gameObjectID, ///< The ID of the game object that the client wishes to query.
             AkUInt32 in_positionIndex,      ///< The index of the associated game object position.
             AkVector64& out_listenerPos,        ///< Returns the position of the listener game object that is associated with the game object \c in_gameObjectID.
             AkVector64& out_emitterPos,     ///< Returns the position of the emitter game object \c in_gameObjectID.
             AkReflectionPathInfo* out_aPaths,   ///< Pointer to an array of \c AkReflectionPathInfo's which will be filled after returning.
             AkUInt32& io_uArraySize         ///< The number of slots in \c out_aPaths, after returning the number of valid elements written.
             );
  
         //@}
  
         ////////////////////////////////////////////////////////////////////////
         /// @name Rooms and Portals
         /// Sound Propagation API using rooms and portals.
         //@{
  
         /// Add or update a room. Rooms are used to connect portals and define an orientation for oriented reverbs. This function may be called multiple times with the same ID to update the parameters of the room.
         /// \akwarning The ID (\c in_RoomID) must be chosen in the same manner as \c AkGameObjectID's, as they are in the same ID-space. The spatial audio lib manages the 
         /// registration/unregistration of internal game objects for rooms that use these IDs and, therefore, must not collide. 
         /// Also, the room ID must not be in the reserved range (AkUInt64)(-32) to (AkUInt64)(-2) inclusively. You may, however, explicitly add the default room ID AK::SpatialAudio::kOutdoorRoomID (-1) 
         /// in order to customize its AkRoomParams, to provide a valid auxiliary bus, for example.\endakwarning
         /// \sa
         /// - \ref AkRoomID
         /// - \ref AkRoomParams
         /// - \ref AK::SpatialAudio::RemoveRoom
         AK_EXTERNAPIFUNC(AKRESULT, SetRoom)(
             AkRoomID in_RoomID,             ///< Unique room ID, chosen by the client.
             const AkRoomParams& in_Params,  ///< Parameter for the room.
             const char* in_RoomName = nullptr   /// Name used to identify room (optional)
             );
  
         /// Remove a room.
         /// \sa
         /// - \ref AkRoomID
         /// - \ref AK::SpatialAudio::SetRoom
         AK_EXTERNAPIFUNC(AKRESULT, RemoveRoom)(
             AkRoomID in_RoomID  ///< Room ID that was passed to \c SetRoom.
             );
  
         /// Add or update an acoustic portal. A portal is an opening that connects two or more rooms to simulate the transmission of reverberated (indirect) sound between the rooms. 
         /// This function may be called multiple times with the same ID to update the parameters of the portal. The ID (\c in_PortalID) must be chosen in the same manner as \c AkGameObjectID's, 
         /// as they are in the same ID-space. The spatial audio lib manages the registration/unregistration of internal game objects for portals that use these IDs, and therefore must not collide.
         /// \sa
         /// - \ref AkPortalID
         /// - \ref AkPortalParams
         /// - \ref AK::SpatialAudio::RemovePortal
         AK_EXTERNAPIFUNC(AKRESULT, SetPortal)(
             AkPortalID in_PortalID,     ///< Unique portal ID, chosen by the client.
             const AkPortalParams& in_Params,    ///< Parameter for the portal.
             const char* in_PortalName = nullptr   /// Name used to identify portal (optional)
             );
  
         /// Remove a portal.
         /// \sa
         /// - \ref AkPortalID
         /// - \ref AK::SpatialAudio::SetPortal
         AK_EXTERNAPIFUNC(AKRESULT, RemovePortal)(
             AkPortalID in_PortalID      ///< ID of portal to be removed, which was originally passed to SetPortal.
             );
  
         /// Set the room that the game object is currently located in - usually the result of a containment test performed by the client. The room must have been registered with \c SetRoom.
         /// Setting the room for a game object provides the basis for the sound propagation service, and also sets which room's reverb aux bus to send to.  The sound propagation service traces the path
         /// of the sound from the emitter to the listener, and calculates the diffraction as the sound passes through each portal.  The portals are used to define the spatial location of the diffracted and reverberated
         /// audio.
         /// \sa 
         /// - \ref AK::SpatialAudio::SetRoom
         /// - \ref AK::SpatialAudio::RemoveRoom
         AK_EXTERNAPIFUNC(AKRESULT, SetGameObjectInRoom)(
             AkGameObjectID in_gameObjectID, ///< Game object ID 
             AkRoomID in_CurrentRoomID       ///< RoomID that was passed to \c AK::SpatialAudio::SetRoom
             );
  
         /// Set the early reflections order for reflection calculation. The reflections order indicates the number of times sound can bounce off of a surface. 
         /// A higher number requires more CPU resources but results in denser early reflections. Set to 0 to globally disable reflections processing.
         AK_EXTERNAPIFUNC(AKRESULT, SetReflectionsOrder)(
             AkUInt32 in_uReflectionsOrder,  ///< Number of reflections to calculate. Valid range [0,4]
             bool in_bUpdatePaths            ///< Set to true to clear existing higher-order paths and to force the re-computation of new paths. If false, existing paths will remain and new paths will be computed when the emitter or listener moves.
             );
  
         /// Set the diffraction order for geometric path calculation. The diffraction order indicates the number of edges a sound can diffract around. 
         /// A higher number requires more CPU resources but results in paths found around more complex geometry. Set to 0 to globally disable geometric diffraction processing.
         /// \sa
         /// - \ref AkSpatialAudioInitSettings::uMaxDiffractionOrder
         AK_EXTERNAPIFUNC(AKRESULT, SetDiffractionOrder)(
             AkUInt32 in_uDiffractionOrder,  ///< Number of diffraction edges to consider in path calculations. Valid range [0,8]
             bool in_bUpdatePaths            ///< Set to true to clear existing diffraction paths and to force the re-computation of new paths. If false, existing paths will remain and new paths will be computed when the emitter or listener moves.
             );
  
         /// Set the number of rays cast from the listener by the stochastic ray casting engine.
         /// A higher number requires more CPU resources but provides more accurate results. Default value (100) should be good for most applications.
         ///
         AK_EXTERNAPIFUNC(AKRESULT, SetNumberOfPrimaryRays)(
             AkUInt32 in_uNbPrimaryRays      ///< Number of rays cast from the listener
             );
  
         /// Set the number of frames on which the path validation phase will be spread. Value between [1..[
         /// High values delay the validation of paths. A value of 1 indicates no spread at all.
         ///
         AK_EXTERNAPIFUNC(AKRESULT, SetLoadBalancingSpread)(
             AkUInt32 in_uNbFrames       ///< Number of spread frames
             );
  
         /// Set an early reflections auxiliary bus for a particular game object. 
         /// Geometrical reflection calculation inside spatial audio is enabled for a game object if any sound playing on the game object has a valid early reflections aux bus specified in the authoring tool,
         /// or if an aux bus is specified via \c SetEarlyReflectionsAuxSend.
         /// The \c in_auxBusID parameter of SetEarlyReflectionsAuxSend applies to sounds playing on the game object \c in_gameObjectID which have not specified an early reflection bus in the authoring tool -
         /// the parameter specified on individual sounds' reflection bus takes priority over the value passed in to \c SetEarlyReflectionsAuxSend.
         /// \aknote 
         /// Users may apply this function to avoid duplicating sounds in the actor-mixer hierarchy solely for the sake of specifying a unique early reflection bus, or in any situation where the same 
         /// sound should be played on different game objects with different early reflection aux buses (the early reflection bus must be left blank in the authoring tool if the user intends to specify it through the API). \endaknote
         AK_EXTERNAPIFUNC(AKRESULT, SetEarlyReflectionsAuxSend)(
             AkGameObjectID in_gameObjectID, ///< Game object ID 
             AkAuxBusID in_auxBusID          ///< Auxiliary bus ID. Applies only to sounds which have not specified an early reflection bus in the authoring tool. Pass \c AK_INVALID_AUX_ID to set only the send volume.
             );
  
         /// Set an early reflections send volume for a particular game object. 
         /// The \c in_fSendVolume parameter is used to control the volume of the early reflections send. It is combined with the early reflections volume specified in the authoring tool, and is applied to all sounds 
         /// playing on the game object.
         /// Setting \c in_fSendVolume to 0.f will disable all reflection processing for this game object.
         AK_EXTERNAPIFUNC(AKRESULT, SetEarlyReflectionsVolume)(
             AkGameObjectID in_gameObjectID, ///< Game object ID 
             AkReal32 in_fSendVolume         ///< Send volume (linear) for auxiliary send. Set 0.f to disable reflection processing. Valid range 0.f-1.f. 
             );
  
         /// Set the obstruction and occlusion value for a portal that has been registered with Spatial Audio.
         /// Portal obstruction simulates objects that block the direct sound path between the portal and the listener, but
         /// allows indirect sound to pass around the obstacle. For example, use portal obstruction 
         /// when a piece of furniture blocks the line of sight of the portal opening.
         /// Portal obstruction is applied to the connection between the emitter and the listener, and only affects the dry signal path.
         /// Portal occlusion simulates a complete blockage of both the direct and indirect sound through a portal. For example, use portal occlusion for 
         /// opening or closing a door or window.
         /// Portal occlusion is applied to the connection between the emitter and the first room in the chain, as well as the connection between the emitter and listener.
         /// Portal occlusion affects both the dry and wet (reverberant) signal paths.
         /// If you are using built-in game parameters to drive RTPCs, the obstruction and occlusion values set here 
         /// do not affect the RTPC values. This behavior is intentional and occurs because RTPCs only provide one 
         /// value per game object, but a single game object can have multiple paths through different Portals, 
         /// each with different obstruction and occlusion values.
         /// To apply detailed obstruction to specific sound paths but not others, use \c AK::SpatialAudio::SetGameObjectToPortalObstruction and \c AK::SpatialAudio::SetPortalToPortalObstruction.
         /// To apply occlusion and obstruction to the direct line of sight between the emitter and listener use \c AK::SoundEngine::SetObjectObstructionAndOcclusion.
         /// \sa
         /// - \ref AK::SpatialAudio::SetGameObjectToPortalObstruction
         /// - \ref AK::SpatialAudio::SetPortalToPortalObstruction
         /// - \ref AK::SoundEngine::SetObjectObstructionAndOcclusion
         AK_EXTERNAPIFUNC(AKRESULT, SetPortalObstructionAndOcclusion)(
             AkPortalID in_PortalID,             ///< Portal ID.
             AkReal32 in_fObstruction,           ///< Obstruction value.  Valid range 0.f-1.f
             AkReal32 in_fOcclusion              ///< Occlusion value.  Valid range 0.f-1.f
             );
  
         /// Set the obstruction value of the path between a game object and a portal that has been created by Spatial Audio.
         /// The obstruction value is applied on one of the path segments of the sound between the emitter and the listener.
         /// Diffraction must be enabled on the sound for a diffraction path to be created.
         /// Also, there should not be any portals between the provided game object and portal ID parameters.
         /// The obstruction value is used to simulate objects between the portal and the game object that are obstructing the sound.
         /// Send an obstruction value of 0 to ensure the value is removed from the internal data structure.
         AK_EXTERNAPIFUNC(AKRESULT, SetGameObjectToPortalObstruction)(
             AkGameObjectID in_gameObjectID,     ///< Game object ID
             AkPortalID in_PortalID,             ///< Portal ID
             AkReal32 in_fObstruction            ///< Obstruction value.  Valid range 0.f-1.f
             );
  
         /// Set the obstruction value of the path between two portals that has been created by Spatial Audio.
         /// The obstruction value is applied on one of the path segments of the sound between the emitter and the listener.
         /// Diffraction must be enabled on the sound for a diffraction path to be created.
         /// Also, there should not be any portals between the two provided ID parameters.
         /// The obstruction value is used to simulate objects between the portals that are obstructing the sound.
         /// Send an obstruction value of 0 to ensure the value is removed from the internal data structure.
         AK_EXTERNAPIFUNC(AKRESULT, SetPortalToPortalObstruction)(
             AkPortalID in_PortalID0,            ///< Portal ID
             AkPortalID in_PortalID1,            ///< Portal ID
             AkReal32 in_fObstruction            ///< Obstruction value.  Valid range 0.f-1.f
             );
  
         /// Query information about the wet diffraction amount for the portal \c in_portal, returned as a normalized value \c out_wetDiffraction in the range [0,1].  
         /// The wet diffraction is calculated from how far into the 'shadow region' the listener is from the portal.  Unlike dry diffraction, the 
         /// wet diffraction does not depend on the incident angle, but only the normal of the portal.
         /// This value is applied by spatial audio, to the Diffraction value and built-in game parameter of the room game object that is
         /// on the other side of the portal (relative to the listener).
         /// This function must acquire the global sound engine lock and therefore, may block waiting for the lock.
         /// \sa
         /// - \ref AkSpatialAudioInitSettings
         AK_EXTERNAPIFUNC(AKRESULT, QueryWetDiffraction)(
             AkPortalID in_portal,           ///< The ID of the game object that the client wishes to query.
             AkReal32& out_wetDiffraction    ///< The number of slots in \c out_aPaths, after returning the number of valid elements written.
             );
  
         /// Query information about the diffraction state for a particular listener and emitter, which has been calculated using the data provided via the spatial audio emitter API. This function can be used for debugging purposes.
         /// Returned in \c out_aPaths, this array contains the sound paths calculated from diffraction around a geometric edge and/or diffraction through portals connecting rooms.
         /// No paths will be returned in any of the following conditions: (1) the emitter game object has a direct line of sight to the listener game object, (2) the emitter and listener are in the same room, and the listener is completely outside the radius of the emitter, 
         /// or (3) The emitter and listener are in different rooms, but there are no paths found via portals between the emitter and the listener.
         /// A single path with zero diffraction nodes is returned when all of the following conditions are met: (1) the emitter and listener are in the same room, (2) there is no direct line of sight, and (3) either the Voice's Attenuation's curve max distance is exceeded or the accumulated diffraction coefficient exceeds 1.0.
         /// This function must acquire the global sound engine lock and, therefore, may block waiting for the lock.
         /// \sa
         /// - \ref AkDiffractionPathInfo
         AK_EXTERNAPIFUNC(AKRESULT, QueryDiffractionPaths)(
             AkGameObjectID in_gameObjectID,     ///< The ID of the game object that the client wishes to query.
             AkUInt32 in_positionIndex,          ///< The index of the associated game object position.
             AkVector64& out_listenerPos,        ///< Returns the position of the listener game object that is associated with the game object \c in_gameObjectID.
             AkVector64& out_emitterPos,         ///< Returns the position of the emitter game object \c in_gameObjectID.
             AkDiffractionPathInfo* out_aPaths,  ///< Pointer to an array of \c AkDiffractionPathInfo's which will be filled on return.
             AkUInt32& io_uArraySize             ///< The number of slots in \c out_aPaths, after returning the number of valid elements written.
             );
  
         /// Reset the stochastic engine state by re-initializing the random seeds.
         ///
         AK_EXTERNAPIFUNC(AKRESULT, ResetStochasticEngine)();
  
         //@}
     }
 };

AkRoomParams::GeometryInstanceID

AkGeometrySetID GeometryInstanceID

Definition: AkSpatialAudio.h:416

AkRoomParams::RoomGameObj_KeepRegistered

bool RoomGameObj_KeepRegistered

Definition: AkSpatialAudio.h:406

AkSpatialAudioTypes.h

AK::SpatialAudio::QueryWetDiffraction

AKSOUNDENGINE_API AKRESULT QueryWetDiffraction(AkPortalID in_portal, AkReal32 &out_wetDiffraction)

AkTriIdx

AkUInt16 AkTriIdx

Definition: AkSpatialAudioTypes.h:84

AK::SpatialAudio::UnregisterListener

AKSOUNDENGINE_API AKRESULT UnregisterListener(AkGameObjectID in_gameObjectID)

AkTriangle

Triangle for a spatial audio mesh.

Definition: AkSpatialAudio.h:141

AkReflectionPathInfo::numPathPoints

AkUInt32 numPathPoints

Number of valid elements in the pathPoint[], surfaces[], and diffraction[] arrays.

Definition: AkSpatialAudio.h:213

AkVertex::AkVertex

AkVertex(AkReal32 in_X, AkReal32 in_Y, AkReal32 in_Z)

Constructor.

Definition: AkSpatialAudio.h:115

AkImageSourceSettings::params

AkImageSourceParams params

Image source parameters.

Definition: AkSpatialAudio.h:102

AkPortalParams

Parameters passed to SetPortal.

Definition: AkSpatialAudio.h:301

AkPortalParams::bEnabled

bool bEnabled

Definition: AkSpatialAudio.h:320

AkSoundEngine.h

AkSpatialAudioInitSettings::fMaxPathLength

AkReal32 fMaxPathLength

Definition: AkSpatialAudio.h:69

Audiokinetic namespace.

Definition: AkWwiseSDKVersion.cs:31

AkRoomParams::TransmissionLoss

AkReal32 TransmissionLoss

Definition: AkSpatialAudio.h:384

AK::SpatialAudio::RemovePortal

AKSOUNDENGINE_API AKRESULT RemovePortal(AkPortalID in_PortalID)

AkRoomParams::Front

AkVector Front

Definition: AkSpatialAudio.h:358

AkGeometryParams::EnableTriangles

bool EnableTriangles

Definition: AkSpatialAudio.h:465

AkGeometryParams::NumTriangles

AkTriIdx NumTriangles

Number of triangles in Triangles.

Definition: AkSpatialAudio.h:433

AkRoomParams::Up

AkVector Up

Definition: AkSpatialAudio.h:362

AkSpatialAudioInitSettings::bEnableGeometricDiffractionAndTransmission

bool bEnableGeometricDiffractionAndTransmission

Definition: AkSpatialAudio.h:75

AkWorldTransform::Set

void Set(const AkVector64 &in_position, const AkVector &in_orientationFront, const AkVector &in_orientationTop)

Set position and orientation. Orientation front and top should be orthogonal and normalized.

Definition: AkTypes.h:514

AkAcousticSurface

Definition: AkSpatialAudio.h:176

AkAcousticSurface::transmissionLoss

AkReal32 transmissionLoss

Definition: AkSpatialAudio.h:192

AkDiffractionPathInfo::totLength

AkReal32 totLength

Definition: AkSpatialAudio.h:292

AkTriangle::point2

AkVertIdx point2

Index into the vertex table passed into AkGeometryParams that describes the third vertex of the trian...

Definition: AkSpatialAudio.h:164

AkRoomParams::RoomGameObj_AuxSendLevelToSelf

AkReal32 RoomGameObj_AuxSendLevelToSelf

Definition: AkSpatialAudio.h:395

AK::SpatialAudio::SetGameObjectInRoom

AKSOUNDENGINE_API AKRESULT SetGameObjectInRoom(AkGameObjectID in_gameObjectID, AkRoomID in_CurrentRoomID)

AkAcousticSurface::AkAcousticSurface

AkAcousticSurface()

Constructor.

Definition: AkSpatialAudio.h:178

AkTriangle::AkTriangle

AkTriangle(AkVertIdx in_pt0, AkVertIdx in_pt1, AkVertIdx in_pt2, AkSurfIdx in_surfaceInfo)

Constructor.

Definition: AkSpatialAudio.h:150

AkVertex::Z

AkReal32 Z

Z coordinate.

Definition: AkSpatialAudio.h:119

AkExtent::halfDepth

AkReal32 halfDepth

Definition: AkSpatialAudio.h:136

AK::SpatialAudio::Init

AKSOUNDENGINE_API AKRESULT Init(const AkSpatialAudioInitSettings &in_initSettings)

Initialize the SpatialAudio API.

AK_DEFAULT_GEOMETRY_POSITION_Z

#define AK_DEFAULT_GEOMETRY_POSITION_Z

Definition: AkSpatialAudio.h:470

AkSpatialAudioInitSettings::AkSpatialAudioInitSettings

AkSpatialAudioInitSettings()

Definition: AkSpatialAudio.h:40

AkPortalParams::AkPortalParams

AkPortalParams()

Constructor.

Definition: AkSpatialAudio.h:303

AK_DEFAULT_GEOMETRY_FRONT_Y

#define AK_DEFAULT_GEOMETRY_FRONT_Y

Definition: AkSpatialAudio.h:472

AkRoomParams::ReverbAuxBus

AkAuxBusID ReverbAuxBus

Definition: AkSpatialAudio.h:372

AK_INVALID_VERTEX

#define AK_INVALID_VERTEX

Definition: AkSpatialAudioTypes.h:89

AkAcousticSurface::textureID

AkUInt32 textureID

Definition: AkSpatialAudio.h:185

AkPortalParams::FrontRoom

AkRoomID FrontRoom

Definition: AkSpatialAudio.h:327

AkSpatialAudioInitSettings::uLoadBalancingSpread

AkUInt32 uLoadBalancingSpread

Spread the computation of paths on uLoadBalancingSpread frames [1..[. When uLoadBalancingSpread is se...

Definition: AkSpatialAudio.h:74

AK::SpatialAudio::QueryDiffractionPaths

AKSOUNDENGINE_API AKRESULT QueryDiffractionPaths(AkGameObjectID in_gameObjectID, AkUInt32 in_positionIndex, AkVector64 &out_listenerPos, AkVector64 &out_emitterPos, AkDiffractionPathInfo *out_aPaths, AkUInt32 &io_uArraySize)

AkRoomParams::AkRoomParams

AkRoomParams()

Constructor.

Definition: AkSpatialAudio.h:341

AkDiffractionPathInfo::nodeCount

AkUInt32 nodeCount

Total number of nodes in the path. Defines the number of valid entries in the nodes,...

Definition: AkSpatialAudio.h:263

AkGameObjectID

AkUInt64 AkGameObjectID

Game object ID.

Definition: AkTypes.h:128

AK_EXTERNAPIFUNC

#define AK_EXTERNAPIFUNC(_type, _name)

Definition: AkSoundEngineExport.h:81

AK::SpatialAudio::SetEarlyReflectionsAuxSend

AKSOUNDENGINE_API AKRESULT SetEarlyReflectionsAuxSend(AkGameObjectID in_gameObjectID, AkAuxBusID in_auxBusID)

AkImageSourceTexture::uNumTexture

AkUInt32 uNumTexture

Number of valid textures in the texture array.

Definition: AkReflectGameData.h:68

AKRESULT

Standard function call result.

Definition: AkTypes.h:199

AkAcousticSurface::strName

const char * strName

Name to describe this surface.

Definition: AkSpatialAudio.h:195

AkSpatialAudioInitSettings::uDiffractionOnReflectionsOrder

AkUInt32 uDiffractionOnReflectionsOrder

Definition: AkSpatialAudio.h:66

AkDiffractionPathInfo::nodes

AkVector64 nodes[kMaxNodes]

Definition: AkSpatialAudio.h:240

AkReflectionPathInfo::surfaces

AkAcousticSurface surfaces[AK_MAX_REFLECTION_PATH_LENGTH]

Definition: AkSpatialAudio.h:210

AkPortalParams::Transform

AkWorldTransform Transform

Definition: AkSpatialAudio.h:311

AkImageSourceID

AkUInt32 AkImageSourceID

Image Source ID.

Definition: AkTypes.h:152

AkReflectionPathInfo::pathPoint

AkVector64 pathPoint[AK_MAX_REFLECTION_PATH_LENGTH]

Definition: AkSpatialAudio.h:206

AK_DEFAULT_GEOMETRY_FRONT_X

#define AK_DEFAULT_GEOMETRY_FRONT_X

Definition: AkSpatialAudio.h:471

AkGeometryParams::Surfaces

AkAcousticSurface * Surfaces

Definition: AkSpatialAudio.h:450

AkVertex::X

AkReal32 X

X coordinate.

Definition: AkSpatialAudio.h:117

AkSpatialAudioInitSettings::fCPULimitPercentage

AkReal32 fCPULimitPercentage

Definition: AkSpatialAudio.h:72

AkReflectGameData.h

AK::SpatialAudio::QueryReflectionPaths

AKSOUNDENGINE_API AKRESULT QueryReflectionPaths(AkGameObjectID in_gameObjectID, AkUInt32 in_positionIndex, AkVector64 &out_listenerPos, AkVector64 &out_emitterPos, AkReflectionPathInfo *out_aPaths, AkUInt32 &io_uArraySize)

AkGeometryParams::NumVertices

AkVertIdx NumVertices

Definition: AkSpatialAudio.h:443

AK::SpatialAudio::RemoveGeometryInstance

AKSOUNDENGINE_API AKRESULT RemoveGeometryInstance(AkGeometryInstanceID in_GeometryInstanceID)

NULL

#define NULL

Definition: AkTypes.h:46

AkRoomParams::ReverbLevel

AkReal32 ReverbLevel

Definition: AkSpatialAudio.h:376

AkReal32

float AkReal32

32-bit floating point

Definition: AkNumeralTypes.h:46

AkSurfIdx

AkUInt16 AkSurfIdx

Definition: AkSpatialAudioTypes.h:85

AkExtent::halfHeight

AkReal32 halfHeight

Definition: AkSpatialAudio.h:135

AkImageSourceParams

Definition: AkReflectGameData.h:73

AkWorldTransform

Position and orientation of game objects in the world (i.e. supports 64-bit-precision position)

Definition: AkTypes.h:485

AK::SpatialAudio::SetImageSource

AKSOUNDENGINE_API AKRESULT SetImageSource(AkImageSourceID in_srcID, const AkImageSourceSettings &in_info, const char *in_name, AkUniqueID in_AuxBusID=AK_INVALID_AUX_ID, AkGameObjectID in_gameObjectID=AK_INVALID_GAME_OBJECT)

AK::SpatialAudio::SetGeometry

AKSOUNDENGINE_API AKRESULT SetGeometry(AkGeometrySetID in_GeomSetID, const AkGeometryParams &in_params)

AkReflectionPathInfo

Structure for retrieving information about the indirect paths of a sound that have been calculated vi...

Definition: AkSpatialAudio.h:200

AkTriangle::surface

AkSurfIdx surface

Definition: AkSpatialAudio.h:168

AK::SpatialAudio::SetPortalToPortalObstruction

AKSOUNDENGINE_API AKRESULT SetPortalToPortalObstruction(AkPortalID in_PortalID0, AkPortalID in_PortalID1, AkReal32 in_fObstruction)

AkGeometryInstanceParams::Scale

AkVector Scale

Definition: AkSpatialAudio.h:506

AkReflectionPathInfo::isOccluded

bool isOccluded

Deprecated - always false. Occluded paths are not generated.

Definition: AkSpatialAudio.h:225

AK::SpatialAudio::SetDiffractionOrder

AKSOUNDENGINE_API AKRESULT SetDiffractionOrder(AkUInt32 in_uDiffractionOrder, bool in_bUpdatePaths)

AkVector::Y

AkReal32 Y

Y Position.

Definition: AkTypes.h:479

AkSpatialAudioInitSettings::bCalcEmitterVirtualPosition

bool bCalcEmitterVirtualPosition

An emitter that is diffracted through a portal or around geometry will have its apparent or virtual p...

Definition: AkSpatialAudio.h:81

AkUniqueID

AkUInt32 AkUniqueID

Unique 32-bit ID.

Definition: AkTypes.h:120

AkImageSourceSettings::SetOneTexture

void SetOneTexture(AkUniqueID in_texture)

Definition: AkSpatialAudio.h:95

AkSpatialAudioInitSettings::uMaxDiffractionOrder

AkUInt32 uMaxDiffractionOrder

Definition: AkSpatialAudio.h:59

AkDiffractionPathInfo::angles

AkReal32 angles[kMaxNodes]

Raw diffraction angles at each point, in radians.

Definition: AkSpatialAudio.h:247

AK_DEFAULT_GEOMETRY_TOP_Z

#define AK_DEFAULT_GEOMETRY_TOP_Z

Definition: AkSpatialAudio.h:476

AkVector::X

AkReal32 X

X Position.

Definition: AkTypes.h:478

AkVertex::Y

AkReal32 Y

Y coordinate.

Definition: AkSpatialAudio.h:118

AK::SpatialAudio::ClearImageSources

AKSOUNDENGINE_API AKRESULT ClearImageSources(AkUniqueID in_AuxBusID=AK_INVALID_AUX_ID, AkGameObjectID in_gameObjectID=AK_INVALID_GAME_OBJECT)

AkExtent

Definition: AkSpatialAudio.h:125

AK::SpatialAudio::SetLoadBalancingSpread

AKSOUNDENGINE_API AKRESULT SetLoadBalancingSpread(AkUInt32 in_uNbFrames)

AkReflectionPathInfo::imageSource

AkVector64 imageSource

Apparent source of the reflected sound that follows this path.

Definition: AkSpatialAudio.h:202

AK::SpatialAudio::SetGeometryInstance

AKSOUNDENGINE_API AKRESULT SetGeometryInstance(AkGeometryInstanceID in_GeometryInstanceID, const AkGeometryInstanceParams &in_params)

AkPortalParams::BackRoom

AkRoomID BackRoom

Definition: AkSpatialAudio.h:334

AkDiffractionPathInfo::emitterPos

AkVector64 emitterPos

Definition: AkSpatialAudio.h:244

AkDiffractionPathInfo::portals

AkPortalID portals[kMaxNodes]

Definition: AkSpatialAudio.h:252

AK_DEFAULT_GEOMETRY_POSITION_X

#define AK_DEFAULT_GEOMETRY_POSITION_X

Definition: AkSpatialAudio.h:468

AkGeometryParams::Triangles

AkTriangle * Triangles

Definition: AkSpatialAudio.h:430

AkPortalParams::Extent

AkExtent Extent

Definition: AkSpatialAudio.h:316

AkDiffractionPathInfo::transmissionLoss

AkReal32 transmissionLoss

Definition: AkSpatialAudio.h:285

AkSpatialAudioInitSettings::uNumberOfPrimaryRays

AkUInt32 uNumberOfPrimaryRays

The number of primary rays used in the ray tracing engine. A larger number of rays will increase the ...

Definition: AkSpatialAudio.h:57

AkVector::Z

AkReal32 Z

Z Position.

Definition: AkTypes.h:480

AkSpatialAudioInitSettings::uMaxReflectionOrder

AkUInt32 uMaxReflectionOrder

Maximum reflection order [1, 4] - the number of 'bounces' in a reflection path. A high reflection ord...

Definition: AkSpatialAudio.h:58

AK_DEFAULT_GEOMETRY_TOP_X

#define AK_DEFAULT_GEOMETRY_TOP_X

Definition: AkSpatialAudio.h:474

AK::SpatialAudio::RemoveImageSource

AKSOUNDENGINE_API AKRESULT RemoveImageSource(AkImageSourceID in_srcID, AkUniqueID in_AuxBusID=AK_INVALID_AUX_ID, AkGameObjectID in_gameObjectID=AK_INVALID_GAME_OBJECT)

AkTriangle::AkTriangle

AkTriangle()

Constructor.

Definition: AkSpatialAudio.h:143

AkSpatialAudioInitSettings

Initialization settings of the spatial audio module.

Definition: AkSpatialAudio.h:39

AkVertex

Vertex for a spatial audio mesh.

Definition: AkSpatialAudio.h:110

AkReflectionPathInfo::diffraction

AkReal32 diffraction[AK_MAX_REFLECTION_PATH_LENGTH]

Diffraction amount, normalized to the range [0,1].

Definition: AkSpatialAudio.h:219

AK_MAX_REFLECTION_PATH_LENGTH

#define AK_MAX_REFLECTION_PATH_LENGTH

Definition: AkSpatialAudioTypes.h:41

AK::SpatialAudio::RemoveRoom

AKSOUNDENGINE_API AKRESULT RemoveRoom(AkRoomID in_RoomID)

AkVertex::AkVertex

AkVertex()

Constructor.

Definition: AkSpatialAudio.h:112

AK::SpatialAudio::SetReflectionsOrder

AKSOUNDENGINE_API AKRESULT SetReflectionsOrder(AkUInt32 in_uReflectionsOrder, bool in_bUpdatePaths)

AkTriangle::point0

AkVertIdx point0

Index into the vertex table passed into AkGeometryParams that describes the first vertex of the trian...

Definition: AkSpatialAudio.h:158

AkSpatialAudioID

Base type for ID's used by Wwise spatial audio.

Definition: AkSpatialAudioTypes.h:96

AkImageSourceSettings

Definition: AkSpatialAudio.h:86

AkReflectionPathInfo::numReflections

AkUInt32 numReflections

Number of reflections in the pathPoint[] array. Shadow zone diffraction does not count as a reflectio...

Definition: AkSpatialAudio.h:216

AK_INVALID_UNIQUE_ID

static const AkUniqueID AK_INVALID_UNIQUE_ID

Invalid unique 32-bit ID.

Definition: AkTypes.h:163

AK::SpatialAudio::SetPortal

AKSOUNDENGINE_API AKRESULT SetPortal(AkPortalID in_PortalID, const AkPortalParams &in_Params, const char *in_PortalName=nullptr)

AK::SpatialAudio::ResetStochasticEngine

AKSOUNDENGINE_API AKRESULT ResetStochasticEngine()

AkGeometryParams::EnableDiffraction

bool EnableDiffraction

Switch to enable or disable geometric diffraction for this Geometry.

Definition: AkSpatialAudio.h:456

AkGeometryInstanceParams

Parameters passed to SetGeometryInstance.

Definition: AkSpatialAudio.h:480

AkGeometryParams::NumSurfaces

AkSurfIdx NumSurfaces

Number of of AkTriangleInfo structures in in_pTriangleInfo and number of AkTriIdx's in in_infoMap.

Definition: AkSpatialAudio.h:453

AkReflectionPathInfo::level

AkReal32 level

Linear gain applied to image source.

Definition: AkSpatialAudio.h:222

AkDiffractionPathInfo::virtualPos

AkWorldTransform virtualPos

Virtual emitter position. This is the position that is passed to the sound engine to render the audio...

Definition: AkSpatialAudio.h:260

AK_DEFAULT_GEOMETRY_TOP_Y

#define AK_DEFAULT_GEOMETRY_TOP_Y

Definition: AkSpatialAudio.h:475

AkDiffractionPathInfo::kMaxNodes

static const AkUInt32 kMaxNodes

Defines the maximum number of nodes that a user can retrieve information about. Longer paths will be ...

Definition: AkSpatialAudio.h:236

AkImageSourceSettings::AkImageSourceSettings

AkImageSourceSettings()

Definition: AkSpatialAudio.h:87

AK_DEFAULT_GEOMETRY_POSITION_Y

#define AK_DEFAULT_GEOMETRY_POSITION_Y

Definition: AkSpatialAudio.h:469

AK::SpatialAudio::SetGameObjectToPortalObstruction

AKSOUNDENGINE_API AKRESULT SetGameObjectToPortalObstruction(AkGameObjectID in_gameObjectID, AkPortalID in_PortalID, AkReal32 in_fObstruction)

AkSpatialAudioInitSettings::fMovementThreshold

AkReal32 fMovementThreshold

Amount that an emitter or listener has to move to trigger a recalculation of reflections/diffraction....

Definition: AkSpatialAudio.h:56

AkDiffractionPathInfo::rooms

AkRoomID rooms[kMaxNodes+1]

Definition: AkSpatialAudio.h:257

AkExtent::halfWidth

AkReal32 halfWidth

Definition: AkSpatialAudio.h:134

AkGeometryParams::EnableDiffractionOnBoundaryEdges

bool EnableDiffractionOnBoundaryEdges

Switch to enable or disable geometric diffraction on boundary edges for this Geometry....

Definition: AkSpatialAudio.h:459

AK_INVALID_GAME_OBJECT

static const AkGameObjectID AK_INVALID_GAME_OBJECT

Invalid game object (may also mean all game objects)

Definition: AkTypes.h:162

AkVector64

3D 64-bit vector. Intended as storage for world positions of sounds and objects, benefiting from 64-b...

Definition: AkTypes.h:390

AkExtent::AkExtent

AkExtent(AkReal32 in_halfWidth, AkReal32 in_halfHeight, AkReal32 in_halfDepth)

Definition: AkSpatialAudio.h:128

AkImageSourceSettings::texture

AkImageSourceTexture texture

Acoustic texture that goes with this image source.

Definition: AkSpatialAudio.h:105

AkImageSourceSettings::AkImageSourceSettings

AkImageSourceSettings(AkVector64 in_sourcePosition, AkReal32 in_fDistanceScalingFactor, AkReal32 in_fLevel)

Definition: AkSpatialAudio.h:89

AkGeometryInstanceParams::RoomID

AkRoomID RoomID

Definition: AkSpatialAudio.h:522

AkUInt32

uint32_t AkUInt32

Unsigned 32-bit integer.

Definition: AkNumeralTypes.h:38

AK_DEFAULT_GEOMETRY_FRONT_Z

#define AK_DEFAULT_GEOMETRY_FRONT_Z

Definition: AkSpatialAudio.h:473

AK_INVALID_SURFACE

#define AK_INVALID_SURFACE

Definition: AkSpatialAudioTypes.h:91

AK_INVALID_AUX_ID

static const AkAuxBusID AK_INVALID_AUX_ID

Invalid auxiliary bus ID (or no Aux bus ID)

Definition: AkTypes.h:169

AkGeometryParams::Vertices

AkVertex * Vertices

Number of vertices in Vertices.

Definition: AkSpatialAudio.h:440

AkAuxBusID

AkUInt32 AkAuxBusID

Auxilliary bus ID.

Definition: AkTypes.h:133

AkRoomID

Definition: AkSpatialAudioTypes.h:131

AkSpatialAudioInitSettings::uMaxSoundPropagationDepth

AkUInt32 uMaxSoundPropagationDepth

Maximum number of portals that sound can propagate through; must be less than or equal to AK_MAX_SOUN...

Definition: AkSpatialAudio.h:55

AkVertIdx

AkUInt16 AkVertIdx

Definition: AkSpatialAudioTypes.h:83

AkVector

3D vector for some operations in 3D space. Typically intended only for localized calculations due to ...

Definition: AkTypes.h:425

AkExtent::AkExtent

AkExtent()

Definition: AkSpatialAudio.h:126

AkGeometryInstanceParams::GeometrySetID

AkGeometrySetID GeometrySetID

Definition: AkSpatialAudio.h:514

AK::SpatialAudio::SetEarlyReflectionsVolume

AKSOUNDENGINE_API AKRESULT SetEarlyReflectionsVolume(AkGameObjectID in_gameObjectID, AkReal32 in_fSendVolume)

AkGeometryParams::AkGeometryParams

AkGeometryParams()

Constructor.

Definition: AkSpatialAudio.h:423

AkDiffractionPathInfo

Definition: AkSpatialAudio.h:234

AkDiffractionPathInfo::diffraction

AkReal32 diffraction

Definition: AkSpatialAudio.h:271

AK::SpatialAudio::SetPortalObstructionAndOcclusion

AKSOUNDENGINE_API AKRESULT SetPortalObstructionAndOcclusion(AkPortalID in_PortalID, AkReal32 in_fObstruction, AkReal32 in_fOcclusion)

AkGeometryInstanceParams::AkGeometryInstanceParams

AkGeometryInstanceParams()

Definition: AkSpatialAudio.h:484

AkDiffractionPathInfo::obstructionValue

AkReal32 obstructionValue

Definition: AkSpatialAudio.h:296

AK::SpatialAudio::RemoveGeometry

AKSOUNDENGINE_API AKRESULT RemoveGeometry(AkGeometrySetID in_SetID)

AkImageSourceTexture::arTextureID

AkUniqueID arTextureID[AK_MAX_NUM_TEXTURE]

Unique IDs of the Acoustics Texture ShareSets used to filter this image source.

Definition: AkReflectGameData.h:69

AkRoomParams

Parameters passed to SetRoom.

Definition: AkSpatialAudio.h:339

AK_MAX_SOUND_PROPAGATION_DEPTH

#define AK_MAX_SOUND_PROPAGATION_DEPTH

Definition: AkSpatialAudioTypes.h:42

AkGeometryParams

Parameters passed to SetGeometry.

Definition: AkSpatialAudio.h:421

AkTriangle::point1

AkVertIdx point1

Index into the vertex table passed into AkGeometryParams that describes the second vertex of the tria...

Definition: AkSpatialAudio.h:161

AkGeometryInstanceParams::PositionAndOrientation

AkWorldTransform PositionAndOrientation

Definition: AkSpatialAudio.h:500

AK::SpatialAudio::RegisterListener

AKSOUNDENGINE_API AKRESULT RegisterListener(AkGameObjectID in_gameObjectID)

AkImageSourceTexture

Definition: AkReflectGameData.h:61

AK::SpatialAudio::SetRoom

AKSOUNDENGINE_API AKRESULT SetRoom(AkRoomID in_RoomID, const AkRoomParams &in_Params, const char *in_RoomName=nullptr)

AK::SpatialAudio::SetGameObjectRadius

AKSOUNDENGINE_API AKRESULT SetGameObjectRadius(AkGameObjectID in_gameObjectID, AkReal32 in_outerRadius, AkReal32 in_innerRadius)

AK::SpatialAudio::SetNumberOfPrimaryRays

AKSOUNDENGINE_API AKRESULT SetNumberOfPrimaryRays(AkUInt32 in_uNbPrimaryRays)

AK_DEFAULT_MOVEMENT_THRESHOLD

#define AK_DEFAULT_MOVEMENT_THRESHOLD

Definition: AkSpatialAudioTypes.h:44

Was this page helpful?

Need Support?

Questions? Problems? Need more info? Contact us, and we can help!

Visit our Support page

Tell us about your project. We're here to help.

Get started with Wwise

Wwise SDK