_ak3_d_objects_8h

Wwise SDK 2025.1.0

 /*******************************************************************************
 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.
 *******************************************************************************/
  
 #pragma once
  
 #include <AK/SoundEngine/Common/AkTypedefs.h>
 #include <AK/SoundEngine/Common/AkEnums.h>
  
 /// 3D 64-bit vector. Intended as storage for world positions of sounds and objects, benefiting from 64-bit precision range
 struct AkVector64
 {
 #ifdef __cplusplus
     inline AkVector64 operator+(const AkVector64& b) const
     {
         AkVector64 v;
  
         v.X = X + b.X;
         v.Y = Y + b.Y;
         v.Z = Z + b.Z;
  
         return v;
     }
  
     inline AkVector64 operator-(const AkVector64& b) const
     {
         AkVector64 v;
  
         v.X = X - b.X;
         v.Y = Y - b.Y;
         v.Z = Z - b.Z;
  
         return v;
     }
  
     inline void Zero()
     {
         X = 0; Y = 0; Z = 0;
     }
 #endif
  
     AkReal64 X; ///< X Position
     AkReal64 Y; ///< Y Position
     AkReal64 Z; ///< Z Position
 };
  
 /// 3D vector for some operations in 3D space. Typically intended only for localized calculations due to 32-bit precision
 struct AkVector
 {
 #ifdef __cplusplus
  
     inline AkVector operator+(const AkVector& b) const
     {
         AkVector v;
  
         v.X = X + b.X;
         v.Y = Y + b.Y;
         v.Z = Z + b.Z;
  
         return v;
     }
  
     inline AkVector operator-(const AkVector& b) const
     {
         AkVector v;
  
         v.X = X - b.X;
         v.Y = Y - b.Y;
         v.Z = Z - b.Z;
  
         return v;
     }
  
     inline AkVector operator*(const AkReal32 f) const
     {
         AkVector v;
  
         v.X = X * f;
         v.Y = Y * f;
         v.Z = Z * f;
  
         return v;
     }
  
     inline AkVector operator/(const AkReal32 f) const
     {
         AkVector v;
  
         v.X = X / f;
         v.Y = Y / f;
         v.Z = Z / f;
  
         return v;
     }
  
     inline void Zero()
     {
         X = 0; Y = 0; Z = 0;
     }
  
     // Helper for implicit conversion to AkVector64. ConvertAkVectorToAkVector64 is still preferable to make it more obvious where upconversion occurs.
     inline operator AkVector64() const { return AkVector64{ X, Y, Z }; }
 #endif
  
     AkReal32 X; ///< X Position
     AkReal32 Y; ///< Y Position
     AkReal32 Z; ///< Z Position
 };
  
 /// Position and orientation of game objects in the world (i.e. supports 64-bit-precision position)
 struct AkWorldTransform
 {
 #ifdef __cplusplus
 public:
     //
     // Getters.
     //
  
     /// Get position vector.
     inline const AkVector64 & Position() const
     {
         return *reinterpret_cast<const AkVector64*>(&position);
     }
  
     /// Get orientation front vector.
     inline const AkVector & OrientationFront() const
     {
         return *reinterpret_cast<const AkVector*>(&orientationFront);
     }
  
     /// Get orientation top vector.
     inline const AkVector & OrientationTop() const
     {
         return *reinterpret_cast<const AkVector*>(&orientationTop);
     }
  
     //
     // Setters.
     //
  
     /// Set position and orientation. Orientation front and top should be orthogonal and normalized.
     inline void Set(
         const AkVector64 & in_position,         ///< Position vector.
         const AkVector & in_orientationFront,   ///< Orientation front
         const AkVector & in_orientationTop      ///< Orientation top
         )
     {
         position = in_position;
         orientationFront = in_orientationFront;
         orientationTop = in_orientationTop;
     }
  
     /// Set position and orientation. Orientation front and top should be orthogonal and normalized.
     inline void Set(
         AkReal64 in_positionX,                  ///< Position x
         AkReal64 in_positionY,                  ///< Position y
         AkReal64 in_positionZ,                  ///< Position z
         AkReal32 in_orientFrontX,               ///< Orientation front x
         AkReal32 in_orientFrontY,               ///< Orientation front y
         AkReal32 in_orientFrontZ,               ///< Orientation front z
         AkReal32 in_orientTopX,                 ///< Orientation top x
         AkReal32 in_orientTopY,                 ///< Orientation top y
         AkReal32 in_orientTopZ                  ///< Orientation top z
         )
     {
         position.X = in_positionX;
         position.Y = in_positionY;
         position.Z = in_positionZ;
         orientationFront.X = in_orientFrontX;
         orientationFront.Y = in_orientFrontY;
         orientationFront.Z = in_orientFrontZ;
         orientationTop.X = in_orientTopX;
         orientationTop.Y = in_orientTopY;
         orientationTop.Z = in_orientTopZ;
     }
     
     /// Set position.
     inline void SetPosition(
         const AkVector64 & in_position          ///< Position vector.
         )
     {
         position = in_position;
     }
  
     /// Set position.
     inline void SetPosition(
         AkReal64 in_x,                          ///< x
         AkReal64 in_y,                          ///< y
         AkReal64 in_z                           ///< z
         )
     {
         position.X = in_x;
         position.Y = in_y;
         position.Z = in_z;
     }
  
     /// Set orientation. Orientation front and top should be orthogonal and normalized.
     inline void SetOrientation(
         const AkVector & in_orientationFront,   ///< Orientation front
         const AkVector & in_orientationTop      ///< Orientation top
         )
     {
         orientationFront = in_orientationFront; 
         orientationTop = in_orientationTop;
     }   
  
     /// Set orientation. Orientation front and top should be orthogonal and normalized.
     inline void SetOrientation(
         AkReal32 in_orientFrontX,               ///< Orientation front x
         AkReal32 in_orientFrontY,               ///< Orientation front y
         AkReal32 in_orientFrontZ,               ///< Orientation front z
         AkReal32 in_orientTopX,                 ///< Orientation top x
         AkReal32 in_orientTopY,                 ///< Orientation top y
         AkReal32 in_orientTopZ                  ///< Orientation top z
         )
     {
         orientationFront.X = in_orientFrontX;
         orientationFront.Y = in_orientFrontY;
         orientationFront.Z = in_orientFrontZ;
         orientationTop.X = in_orientTopX;
         orientationTop.Y = in_orientTopY;
         orientationTop.Z = in_orientTopZ;
     }
 #endif
  
     struct AkVector    orientationFront;  ///< Orientation of the listener
     struct AkVector    orientationTop;    ///< Top orientation of the listener
     struct AkVector64  position;          ///< Position of the listener
 };
  
 /// Position and orientation of objects in a "local" space
 struct AkTransform
 {
 #ifdef __cplusplus
 public:
     //
     // Getters.
     //
  
     /// Get position vector.
     inline const AkVector& Position() const
     {
         return position;
     }
  
     /// Get orientation front vector.
     inline const AkVector& OrientationFront() const
     {
         return orientationFront;
     }
  
     /// Get orientation top vector.
     inline const AkVector& OrientationTop() const
     {
         return orientationTop;
     }
  
     //
     // Setters.
     //
  
     /// Set position and orientation. Orientation front and top should be orthogonal and normalized.
     inline void Set(
         const AkVector& in_position,            ///< Position vector.
         const AkVector& in_orientationFront,    ///< Orientation front
         const AkVector& in_orientationTop       ///< Orientation top
     )
     {
         position = in_position;
         orientationFront = in_orientationFront;
         orientationTop = in_orientationTop;
     }
  
     /// Set position and orientation. Orientation front and top should be orthogonal and normalized.
     inline void Set(
         AkReal32 in_positionX,                  ///< Position x
         AkReal32 in_positionY,                  ///< Position y
         AkReal32 in_positionZ,                  ///< Position z
         AkReal32 in_orientFrontX,               ///< Orientation front x
         AkReal32 in_orientFrontY,               ///< Orientation front y
         AkReal32 in_orientFrontZ,               ///< Orientation front z
         AkReal32 in_orientTopX,                 ///< Orientation top x
         AkReal32 in_orientTopY,                 ///< Orientation top y
         AkReal32 in_orientTopZ                  ///< Orientation top z
     )
     {
         position.X = in_positionX;
         position.Y = in_positionY;
         position.Z = in_positionZ;
         orientationFront.X = in_orientFrontX;
         orientationFront.Y = in_orientFrontY;
         orientationFront.Z = in_orientFrontZ;
         orientationTop.X = in_orientTopX;
         orientationTop.Y = in_orientTopY;
         orientationTop.Z = in_orientTopZ;
     }
  
     /// Set position.
     inline void SetPosition(
         const AkVector& in_position         ///< Position vector.
     )
     {
         position = in_position;
     }
  
     /// Set position.
     inline void SetPosition(
         AkReal32 in_x,                          ///< x
         AkReal32 in_y,                          ///< y
         AkReal32 in_z                           ///< z
     )
     {
         position.X = in_x;
         position.Y = in_y;
         position.Z = in_z;
     }
  
     /// Set orientation. Orientation front and top should be orthogonal and normalized.
     inline void SetOrientation(
         const AkVector& in_orientationFront,    ///< Orientation front
         const AkVector& in_orientationTop       ///< Orientation top
     )
     {
         orientationFront = in_orientationFront;
         orientationTop = in_orientationTop;
     }
  
     /// Set orientation. Orientation front and top should be orthogonal and normalized.
     inline void SetOrientation(
         AkReal32 in_orientFrontX,               ///< Orientation front x
         AkReal32 in_orientFrontY,               ///< Orientation front y
         AkReal32 in_orientFrontZ,               ///< Orientation front z
         AkReal32 in_orientTopX,                 ///< Orientation top x
         AkReal32 in_orientTopY,                 ///< Orientation top y
         AkReal32 in_orientTopZ                  ///< Orientation top z
     )
     {
         orientationFront.X = in_orientFrontX;
         orientationFront.Y = in_orientFrontY;
         orientationFront.Z = in_orientFrontZ;
         orientationTop.X = in_orientTopX;
         orientationTop.Y = in_orientTopY;
         orientationTop.Z = in_orientTopZ;
     }
  
     // Helper for implicit conversion to AkWorldTransform. ConvertAkTransformToAkWorldTransform is still preferable to make it more obvious where upconversion occurs.
     inline operator AkWorldTransform() const {
         AkWorldTransform ret;
         ret.Set(position, orientationFront, orientationTop);
         return ret;
     }
  
 #endif
  
     struct AkVector orientationFront;   ///< Orientation of the listener
     struct AkVector orientationTop;     ///< Top orientation of the listener
     struct AkVector position;           ///< Position of the listener
 };
  
 /// Positioning information for a sound.
 typedef struct AkWorldTransform AkSoundPosition;
  
 /// Positioning information for a listener.
 typedef struct AkWorldTransform AkListenerPosition;
  
 /// Positioning information for a sound, with specified subset of its channels.
 struct AkChannelEmitter
 {
     struct AkWorldTransform position;         ///< Emitter position.
     AkChannelMask           uInputChannels;   ///< Channels to which the above position applies.
 };
  
 /// Polar coordinates.
 struct AkPolarCoord
 {
     AkReal32 r;     ///< Norm/distance
     AkReal32 theta; ///< Azimuth
 };
  
 #ifdef __cplusplus
 namespace AK
 {
     // Helper functions to make transitions between 64b and 32b conversion easier
  
     // Warning: this conversion incurs a loss of precision and range
     inline AkVector ConvertAkVector64ToAkVector(AkVector64 in)
     {
         AkVector out;
         out.X = (AkReal32)in.X;
         out.Y = (AkReal32)in.Y;
         out.Z = (AkReal32)in.Z;
         return out;
     }
  
     // Warning: this conversion incurs a loss of precision and range in position data
     inline AkTransform ConvertAkWorldTransformToAkTransform(AkWorldTransform in)
     {
         AkTransform out;
         AkVector pos = ConvertAkVector64ToAkVector(in.Position());
         out.Set(pos, in.OrientationFront(), in.OrientationTop());
         return out;
     }
  
     inline AkVector64 ConvertAkVectorToAkVector64(AkVector in)
     {
         AkVector64 out;
         out.X = (AkReal64)in.X;
         out.Y = (AkReal64)in.Y;
         out.Z = (AkReal64)in.Z;
         return out;
     }
  
     inline AkWorldTransform ConvertAkTransformToAkWorldTransform(AkTransform in)
     {
         AkWorldTransform out;
         AkVector64 pos = ConvertAkVectorToAkVector64(in.Position());
         out.Set(pos, in.OrientationFront(), in.OrientationTop());
         return out;
     }
  
     // \deprecated Use AkMultiPositionType.
     using MultiPositionType = AkMultiPositionType;
     const AkMultiPositionType MultiPositionType_SingleSource = AkMultiPositionType_SingleSource;
     const AkMultiPositionType MultiPositionType_MultiSources = AkMultiPositionType_MultiSources;
     const AkMultiPositionType MultiPositionType_MultiDirections = AkMultiPositionType_MultiDirections;
     const AkMultiPositionType MultiPositionType_Last = AkMultiPositionType_Last;
 }
  
 /// Spherical coordinates.
 struct AkSphericalCoord : public AkPolarCoord
 {
     AkReal32        phi;            ///< Elevation
 };
  
 /// Emitter-listener pair: Positioning data pertaining to a single pair of emitter and listener.
 class AkEmitterListenerPair
 {
 public:
     /// Constructor.
     AkEmitterListenerPair()
         : fDistance(0.f)
         , fEmitterAngle(0.f)
         , fListenerAngle(0.f)   
         , fDryMixGain(1.f)
         , fGameDefAuxMixGain(1.f)
         , fUserDefAuxMixGain(1.f)
         , fOcclusion(0.f)
         , fObstruction(0.f)
         , fDiffraction(0.f)
         , fTransmissionLoss(0.f)
         , fSpread(0.f)
         , fAperture(100.f)
         , fScalingFactor(1.f)
         , fPathGain(1.f)
         , uEmitterChannelMask(0xFFFFFFFF)
         , id(0)
         , m_uListenerID(0)
     {
     }
     /// Destructor.
     ~AkEmitterListenerPair() {}
  
     /// Get distance.
     inline AkReal32 Distance() const { return fDistance; }
  
     /// Get the absolute angle, in radians between 0 and pi, of the emitter's orientation relative to 
     /// the line that joins the emitter and the listener.
     inline AkReal32 EmitterAngle() const { return fEmitterAngle; }
  
     /// Get the absolute angle, in radians between 0 and pi, of the listener's orientation relative to
     /// the line that joins the emitter and the listener
     inline AkReal32 ListenerAngle() const { return fListenerAngle; }
  
     /// Get the occlusion factor for this emitter-listener pair
     inline AkReal32 Occlusion() const { return fOcclusion; }
  
     /// Get the obstruction factor for this emitter-listener pair
     inline AkReal32 Obstruction() const { return fObstruction; }    
  
     /// Get the diffraction factor for this emitter-listener pair
     inline AkReal32 Diffraction() const { return fDiffraction; }
  
     /// Get the transmission loss factor for this emitter-listener pair
     inline AkReal32 TransmissionLoss() const { return fTransmissionLoss; }
  
     /// Get the overall path-contribution gain, used to scale the dry + gamedef + userdef gains
     inline AkReal32 PathGain() const { return fPathGain; }
  
     /// Get the emitter-listener-pair-specific gain (due to distance and cone attenuation), linear [0,1], for a given connection type.
     inline AkReal32 GetGainForConnectionType(AkConnectionType in_eType) const
     {
         if (in_eType == ConnectionType_Direct)
             return fDryMixGain;
         else if (in_eType == ConnectionType_GameDefSend)
             return fGameDefAuxMixGain;
         else if (in_eType == ConnectionType_UserDefSend)
             return fUserDefAuxMixGain;
         else
             return 1.0f;
     }
  
     /// Get the emitter-listener pair's ID.
     inline AkRayID ID() const { return id; }
  
     /// Get listener ID associated with the emitter-listener pair.
     inline AkGameObjectID ListenerID() const { return m_uListenerID; }
     
     AkWorldTransform emitter;           ///< Emitter position.
     AkReal32 fDistance;                 ///< Distance between emitter and listener.
     AkReal32 fEmitterAngle;             ///< Angle between position vector and emitter orientation.
     AkReal32 fListenerAngle;            ///< Angle between position vector and listener orientation.    
     AkReal32 fDryMixGain;               ///< Emitter-listener-pair-specific gain (due to distance and cone attenuation) for direct connections.
     AkReal32 fGameDefAuxMixGain;        ///< Emitter-listener-pair-specific gain (due to distance and cone attenuation) for game-defined send connections.
     AkReal32 fUserDefAuxMixGain;        ///< Emitter-listener-pair-specific gain (due to distance and cone attenuation) for user-defined send connections.
     AkReal32 fOcclusion;                ///< Emitter-listener-pair-specific occlusion factor
     AkReal32 fObstruction;              ///< Emitter-listener-pair-specific obstruction factor
     AkReal32 fDiffraction;              ///< Emitter-listener-pair-specific diffraction coefficient
     AkReal32 fTransmissionLoss;         ///< Emitter-listener-pair-specific transmission occlusion.
     AkReal32 fSpread;                   ///< Emitter-listener-pair-specific spread
     AkReal32 fAperture;                 ///< Emitter-listener-pair-specific aperture
     AkReal32 fScalingFactor;            ///< Combined scaling factor due to both emitter and listener.
     AkReal32 fPathGain;                 ///< Emitter-listener-pair-specific overall gain that scales fDryMixGain, fGameDefAuxMixGain and fUserDefAuxMixGain
     AkChannelMask uEmitterChannelMask;  ///< Channels of the emitter that apply to this ray.
  
 protected:
     AkRayID id;                         ///< ID of this emitter-listener pair, unique for a given emitter.
     AkGameObjectID m_uListenerID;       ///< Listener game object ID.
 };
 #endif
  
 /// Listener information.
 struct AkListener
 {
 #ifdef __cplusplus
     AkListener()
         : fScalingFactor( 1.0f )
         , bSpatialized( true )
     {}
 #endif
     AkListenerPosition  position;       /// Listener position (see AK::SoundEngine::SetPosition()).
     AkReal32            fScalingFactor; /// Listener scaling factor (see AK::SoundEngine::SetListenerScalingFactor()).
     bool                bSpatialized;   /// Whether listener is spatialized or not (see AK::SoundEngine::SetListenerSpatialization()).
 };

AkEmitterListenerPair::AkEmitterListenerPair

AkEmitterListenerPair()

Constructor.

Definition: Ak3DObjects.h:462

AkEmitterListenerPair::m_uListenerID

AkGameObjectID m_uListenerID

Listener game object ID.

Definition: Ak3DObjects.h:549

AkTransform::SetOrientation

void SetOrientation(AkReal32 in_orientFrontX, AkReal32 in_orientFrontY, AkReal32 in_orientFrontZ, AkReal32 in_orientTopX, AkReal32 in_orientTopY, AkReal32 in_orientTopZ)

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

Definition: Ak3DObjects.h:351

AkConnectionType

Nature of the connection binding an input to a bus.

Definition: AkEnums.h:139

AkEmitterListenerPair::Occlusion

AkReal32 Occlusion() const

Get the occlusion factor for this emitter-listener pair.

Definition: Ak3DObjects.h:497

AkVector::Zero

void Zero()

Definition: Ak3DObjects.h:118

AK::ConvertAkVectorToAkVector64

AkVector64 ConvertAkVectorToAkVector64(AkVector in)

Definition: Ak3DObjects.h:426

Definition of data structures for AkAudioObject.

Definition: AkWwiseSDKVersion.cs:31

ConnectionType_Direct

@ ConnectionType_Direct

Direct (main, dry) connection.

Definition: AkEnums.h:140

AkEmitterListenerPair::fEmitterAngle

AkReal32 fEmitterAngle

Angle between position vector and emitter orientation.

Definition: Ak3DObjects.h:532

AkEmitterListenerPair::Diffraction

AkReal32 Diffraction() const

Get the diffraction factor for this emitter-listener pair.

Definition: Ak3DObjects.h:503

AkWorldTransform::SetOrientation

void SetOrientation(const AkVector &in_orientationFront, const AkVector &in_orientationTop)

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

Definition: Ak3DObjects.h:220

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: Ak3DObjects.h:164

AkSphericalCoord::phi

AkReal32 phi

Elevation.

Definition: Ak3DObjects.h:454

AkVector64::Zero

void Zero()

Definition: Ak3DObjects.h:58

AkWorldTransform::SetOrientation

void SetOrientation(AkReal32 in_orientFrontX, AkReal32 in_orientFrontY, AkReal32 in_orientFrontZ, AkReal32 in_orientTopX, AkReal32 in_orientTopY, AkReal32 in_orientTopZ)

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

Definition: Ak3DObjects.h:230

AkEmitterListenerPair::Distance

AkReal32 Distance() const

Get distance.

Definition: Ak3DObjects.h:486

AkGameObjectID

AkUInt64 AkGameObjectID

Game object ID.

Definition: AkTypedefs.h:47

AkVector::operator/

AkVector operator/(const AkReal32 f) const

Definition: Ak3DObjects.h:107

AkEmitterListenerPair::fSpread

AkReal32 fSpread

Emitter-listener-pair-specific spread.

Definition: Ak3DObjects.h:541

AkPolarCoord::r

AkReal32 r

Norm/distance.

Definition: Ak3DObjects.h:398

AkTransform::orientationFront

struct AkVector orientationFront

Orientation of the listener.

Definition: Ak3DObjects.h:377

AkTransform::OrientationTop

const AkVector & OrientationTop() const

Get orientation top vector.

Definition: Ak3DObjects.h:275

AkVector64::operator-

AkVector64 operator-(const AkVector64 &b) const

Definition: Ak3DObjects.h:47

AkRayID

AkUInt32 AkRayID

Unique (per emitter) identifier for an emitter-listener ray.

Definition: AkTypedefs.h:74

AkEmitterListenerPair::fDistance

AkReal32 fDistance

Distance between emitter and listener.

Definition: Ak3DObjects.h:531

AkWorldTransform::Set

void Set(AkReal64 in_positionX, AkReal64 in_positionY, AkReal64 in_positionZ, AkReal32 in_orientFrontX, AkReal32 in_orientFrontY, AkReal32 in_orientFrontZ, AkReal32 in_orientTopX, AkReal32 in_orientTopY, AkReal32 in_orientTopZ)

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

Definition: Ak3DObjects.h:176

AkWorldTransform::position

struct AkVector64 position

Position of the listener.

Definition: Ak3DObjects.h:250

ConnectionType_GameDefSend

@ ConnectionType_GameDefSend

Connection by a game-defined send.

Definition: AkEnums.h:141

AkEmitterListenerPair::PathGain

AkReal32 PathGain() const

Get the overall path-contribution gain, used to scale the dry + gamedef + userdef gains.

Definition: Ak3DObjects.h:509

AK::MultiPositionType_SingleSource

const AkMultiPositionType MultiPositionType_SingleSource

Definition: Ak3DObjects.h:445

AkTransform::Set

void Set(AkReal32 in_positionX, AkReal32 in_positionY, AkReal32 in_positionZ, AkReal32 in_orientFrontX, AkReal32 in_orientFrontY, AkReal32 in_orientFrontZ, AkReal32 in_orientTopX, AkReal32 in_orientTopY, AkReal32 in_orientTopZ)

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

Definition: Ak3DObjects.h:297

AkEnums.h

AkWorldTransform::SetPosition

void SetPosition(const AkVector64 &in_position)

Set position.

Definition: Ak3DObjects.h:200

AkTransform::SetPosition

void SetPosition(const AkVector &in_position)

Set position.

Definition: Ak3DObjects.h:321

AkTransform::SetPosition

void SetPosition(AkReal32 in_x, AkReal32 in_y, AkReal32 in_z)

Set position.

Definition: Ak3DObjects.h:329

AkEmitterListenerPair::emitter

AkWorldTransform emitter

Emitter position.

Definition: Ak3DObjects.h:530

AkMultiPositionType_Last

@ AkMultiPositionType_Last

End of enum, invalid value.

Definition: AkEnums.h:320

AkTransform

Position and orientation of objects in a "local" space.

Definition: Ak3DObjects.h:255

AkReal32

float AkReal32

32-bit floating point

Definition: AkNumeralTypes.h:43

AkEmitterListenerPair::fObstruction

AkReal32 fObstruction

Emitter-listener-pair-specific obstruction factor.

Definition: Ak3DObjects.h:538

AkEmitterListenerPair

Emitter-listener pair: Positioning data pertaining to a single pair of emitter and listener.

Definition: Ak3DObjects.h:459

ConnectionType_UserDefSend

@ ConnectionType_UserDefSend

Connection by a user-defined send.

Definition: AkEnums.h:142

AkEmitterListenerPair::fGameDefAuxMixGain

AkReal32 fGameDefAuxMixGain

Emitter-listener-pair-specific gain (due to distance and cone attenuation) for game-defined send conn...

Definition: Ak3DObjects.h:535

AkEmitterListenerPair::fPathGain

AkReal32 fPathGain

Emitter-listener-pair-specific overall gain that scales fDryMixGain, fGameDefAuxMixGain and fUserDefA...

Definition: Ak3DObjects.h:544

AkChannelEmitter::position

struct AkWorldTransform position

Emitter position.

Definition: Ak3DObjects.h:391

AkEmitterListenerPair::EmitterAngle

AkReal32 EmitterAngle() const

Definition: Ak3DObjects.h:490

AkVector::Y

AkReal32 Y

Y Position.

Definition: Ak3DObjects.h:128

AkWorldTransform::Position

const AkVector64 & Position() const

Get position vector.

Definition: Ak3DObjects.h:142

AK::ConvertAkTransformToAkWorldTransform

AkWorldTransform ConvertAkTransformToAkWorldTransform(AkTransform in)

Definition: Ak3DObjects.h:435

AkListener::position

AkListenerPosition position

Definition: Ak3DObjects.h:562

AkVector::operator+

AkVector operator+(const AkVector &b) const

Definition: Ak3DObjects.h:74

AkEmitterListenerPair::ListenerID

AkGameObjectID ListenerID() const

Get listener ID associated with the emitter-listener pair.

Definition: Ak3DObjects.h:528

AkVector::X

AkReal32 X

X Position.

Definition: Ak3DObjects.h:127

AkWorldTransform::orientationTop

struct AkVector orientationTop

Top orientation of the listener.

Definition: Ak3DObjects.h:249

AkTransform::SetOrientation

void SetOrientation(const AkVector &in_orientationFront, const AkVector &in_orientationTop)

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

Definition: Ak3DObjects.h:341

AkSphericalCoord

Spherical coordinates.

Definition: Ak3DObjects.h:453

AkEmitterListenerPair::fDiffraction

AkReal32 fDiffraction

Emitter-listener-pair-specific diffraction coefficient.

Definition: Ak3DObjects.h:539

AkMultiPositionType_MultiDirections

@ AkMultiPositionType_MultiDirections

Simulate one sound coming from multiple directions. Useful for repositionning sounds based on wall op...

Definition: AkEnums.h:318

AK::MultiPositionType_MultiSources

const AkMultiPositionType MultiPositionType_MultiSources

Definition: Ak3DObjects.h:446

AkEmitterListenerPair::Obstruction

AkReal32 Obstruction() const

Get the obstruction factor for this emitter-listener pair.

Definition: Ak3DObjects.h:500

AkTransform::Set

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

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

Definition: Ak3DObjects.h:285

AkChannelEmitter

Positioning information for a sound, with specified subset of its channels.

Definition: Ak3DObjects.h:390

AkMultiPositionType

Definition: AkEnums.h:315

AkTransform::OrientationFront

const AkVector & OrientationFront() const

Get orientation front vector.

Definition: Ak3DObjects.h:269

AkVector::Z

AkReal32 Z

Z Position.

Definition: Ak3DObjects.h:129

AkTransform::Position

const AkVector & Position() const

Get position vector.

Definition: Ak3DObjects.h:263

AkPolarCoord

Polar coordinates.

Definition: Ak3DObjects.h:397

AkVector::operator-

AkVector operator-(const AkVector &b) const

Definition: Ak3DObjects.h:85

AkEmitterListenerPair::GetGainForConnectionType

AkReal32 GetGainForConnectionType(AkConnectionType in_eType) const

Get the emitter-listener-pair-specific gain (due to distance and cone attenuation),...

Definition: Ak3DObjects.h:512

AK::ConvertAkWorldTransformToAkTransform

AkTransform ConvertAkWorldTransformToAkTransform(AkWorldTransform in)

Definition: Ak3DObjects.h:418

AkReal64

double AkReal64

64-bit floating point

Definition: AkNumeralTypes.h:44

AkVector::operator*

AkVector operator*(const AkReal32 f) const

Definition: Ak3DObjects.h:96

AkListener::bSpatialized

bool bSpatialized

Listener scaling factor (see AK::SoundEngine::SetListenerScalingFactor()).

Definition: Ak3DObjects.h:564

AK::ConvertAkVector64ToAkVector

AkVector ConvertAkVector64ToAkVector(AkVector64 in)

Definition: Ak3DObjects.h:408

AkEmitterListenerPair::fScalingFactor

AkReal32 fScalingFactor

Combined scaling factor due to both emitter and listener.

Definition: Ak3DObjects.h:543

AkEmitterListenerPair::fDryMixGain

AkReal32 fDryMixGain

Emitter-listener-pair-specific gain (due to distance and cone attenuation) for direct connections.

Definition: Ak3DObjects.h:534

AkEmitterListenerPair::fOcclusion

AkReal32 fOcclusion

Emitter-listener-pair-specific occlusion factor.

Definition: Ak3DObjects.h:537

AkVector64::Y

AkReal64 Y

Y Position.

Definition: Ak3DObjects.h:65

AkWorldTransform::OrientationFront

const AkVector & OrientationFront() const

Get orientation front vector.

Definition: Ak3DObjects.h:148

AkEmitterListenerPair::fListenerAngle

AkReal32 fListenerAngle

Angle between position vector and listener orientation.

Definition: Ak3DObjects.h:533

AkEmitterListenerPair::uEmitterChannelMask

AkChannelMask uEmitterChannelMask

Channels of the emitter that apply to this ray.

Definition: Ak3DObjects.h:545

AkEmitterListenerPair::fTransmissionLoss

AkReal32 fTransmissionLoss

Emitter-listener-pair-specific transmission occlusion.

Definition: Ak3DObjects.h:540

AkWorldTransform::SetPosition

void SetPosition(AkReal64 in_x, AkReal64 in_y, AkReal64 in_z)

Set position.

Definition: Ak3DObjects.h:208

AK::MultiPositionType_Last

const AkMultiPositionType MultiPositionType_Last

Definition: Ak3DObjects.h:448

AkPolarCoord::theta

AkReal32 theta

Azimuth.

Definition: Ak3DObjects.h:399

AkWorldTransform::orientationFront

struct AkVector orientationFront

Orientation of the listener.

Definition: Ak3DObjects.h:248

AkListener::AkListener

AkListener()

Definition: Ak3DObjects.h:557

AkEmitterListenerPair::ID

AkRayID ID() const

Get the emitter-listener pair's ID.

Definition: Ak3DObjects.h:525

AkVector64

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

Definition: Ak3DObjects.h:34

AkEmitterListenerPair::id

AkRayID id

ID of this emitter-listener pair, unique for a given emitter.

Definition: Ak3DObjects.h:548

AkWorldTransform

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

Definition: Ak3DObjects.h:134

AkTypedefs.h

AkEmitterListenerPair::fUserDefAuxMixGain

AkReal32 fUserDefAuxMixGain

Emitter-listener-pair-specific gain (due to distance and cone attenuation) for user-defined send conn...

Definition: Ak3DObjects.h:536

AkTransform::position

struct AkVector position

Position of the listener.

Definition: Ak3DObjects.h:379

AkEmitterListenerPair::~AkEmitterListenerPair

~AkEmitterListenerPair()

Destructor.

Definition: Ak3DObjects.h:483

AkVector64::operator+

AkVector64 operator+(const AkVector64 &b) const

Definition: Ak3DObjects.h:36

AkVector

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

Definition: Ak3DObjects.h:71

AK::MultiPositionType_MultiDirections

const AkMultiPositionType MultiPositionType_MultiDirections

Definition: Ak3DObjects.h:447

AkMultiPositionType_MultiSources

@ AkMultiPositionType_MultiSources

Simulate multiple sources in one sound playing, adding volumes. For instance, all the torches on your...

Definition: AkEnums.h:317

AkChannelEmitter::uInputChannels

AkChannelMask uInputChannels

Channels to which the above position applies.

Definition: Ak3DObjects.h:392

AkListener::fScalingFactor

AkReal32 fScalingFactor

Listener position (see AK::SoundEngine::SetPosition()).

Definition: Ak3DObjects.h:563

AkEmitterListenerPair::ListenerAngle

AkReal32 ListenerAngle() const

Definition: Ak3DObjects.h:494

AkListener

Listener information.

Definition: Ak3DObjects.h:555

AkChannelMask

AkUInt32 AkChannelMask

Channel mask (similar to extensibleWavFormat). Bit values are defined in AkSpeakerConfig....

Definition: AkTypedefs.h:68

AkEmitterListenerPair::TransmissionLoss

AkReal32 TransmissionLoss() const

Get the transmission loss factor for this emitter-listener pair.

Definition: Ak3DObjects.h:506

AkEmitterListenerPair::fAperture

AkReal32 fAperture

Emitter-listener-pair-specific aperture.

Definition: Ak3DObjects.h:542

AkMultiPositionType_SingleSource

@ AkMultiPositionType_SingleSource

Used for normal sounds, not expected to pass to AK::SoundEngine::SetMultiplePosition() (if done,...

Definition: AkEnums.h:316

AkVector64::Z

AkReal64 Z

Z Position.

Definition: Ak3DObjects.h:66

AkVector64::X

AkReal64 X

X Position.

Definition: Ak3DObjects.h:64

AkTransform::orientationTop

struct AkVector orientationTop

Top orientation of the listener.

Definition: Ak3DObjects.h:378

AkWorldTransform::OrientationTop

const AkVector & OrientationTop() const

Get orientation top vector.

Definition: Ak3DObjects.h:154

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

_ak3_d_objects_8h_source

Was this page helpful?

Need Support?

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