Version
menu_open
link

include/AK/SoundEngine/Common/AkTypes.h

Go to the documentation of this file.
00001 /*******************************************************************************
00002 The content of this file includes portions of the AUDIOKINETIC Wwise Technology
00003 released in source code form as part of the SDK installer package.
00004 
00005 Commercial License Usage
00006 
00007 Licensees holding valid commercial licenses to the AUDIOKINETIC Wwise Technology
00008 may use this file in accordance with the end user license agreement provided 
00009 with the software or, alternatively, in accordance with the terms contained in a
00010 written agreement between you and Audiokinetic Inc.
00011 
00012 Apache License Usage
00013 
00014 Alternatively, this file may be used under the Apache License, Version 2.0 (the 
00015 "Apache License"); you may not use this file except in compliance with the 
00016 Apache License. You may obtain a copy of the Apache License at 
00017 http://www.apache.org/licenses/LICENSE-2.0.
00018 
00019 Unless required by applicable law or agreed to in writing, software distributed
00020 under the Apache License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES
00021 OR CONDITIONS OF ANY KIND, either express or implied. See the Apache License for
00022 the specific language governing permissions and limitations under the License.
00023 
00024   Version: <VERSION>  Build: <BUILDNUMBER>
00025   Copyright (c) <COPYRIGHTYEAR> Audiokinetic Inc.
00026 *******************************************************************************/
00027 
00028 // AkTypes.h
00029 
00030 /// \file 
00031 /// Data type definitions.
00032 
00033 #ifndef _AK_DATA_TYPES_H_
00034 #define _AK_DATA_TYPES_H_
00035 
00036 // Platform-specific section.
00037 //----------------------------------------------------------------------------------------------------
00038 #include <AK/AkPlatforms.h>
00039 
00040 
00041 //----------------------------------------------------------------------------------------------------
00042 
00043 #include <AK/SoundEngine/Common/AkSoundEngineExport.h>
00044 
00045 #ifndef NULL
00046     #ifdef __cplusplus
00047         #define NULL    0
00048     #else
00049         #define NULL    ((void *)0)
00050     #endif
00051 #endif
00052 
00053 #if defined(AK_CPU_X86_64) || defined(AK_CPU_ARM_64)
00054 #define AK_POINTER_64
00055 #endif // #if defined(AK_CPU_X86_64) || defined(AK_CPU_ARM_64)
00056 
00057 typedef AkInt32             AkAtomic32;         ///< Signed 32-bit integer - Atomic Declaration
00058 typedef AkInt64             AkAtomic64;         ///< Signed 64-bit integer - Atomic Declaration
00059 typedef AkUInt32            AkAtomicU32;        ///< Unsigned 32-bit integer - Atomic Declaration
00060 typedef AkIntPtr            AkAtomicPtr;        ///< Signed platform sized integer - Atomic Declaration
00061 
00062 typedef AkUInt32        AkUniqueID;                 ///< Unique 32-bit ID
00063 typedef AkUInt32        AkStateID;                  ///< State ID
00064 typedef AkUInt32        AkStateGroupID;             ///< State group ID
00065 typedef AkUInt32        AkPlayingID;                ///< Playing ID
00066 typedef AkInt32         AkTimeMs;                   ///< Time in ms
00067 typedef AkUInt16        AkPortNumber;               ///< Port number
00068 typedef AkReal32        AkPitchValue;               ///< Pitch value
00069 typedef AkReal32        AkVolumeValue;              ///< Volume value( also apply to LFE )
00070 typedef AkUInt64        AkGameObjectID;             ///< Game object ID
00071 typedef AkReal32        AkLPFType;                  ///< Low-pass filter type
00072 typedef AkInt32         AkMemPoolId;                ///< Memory pool ID
00073 typedef AkUInt32        AkPluginID;                 ///< Source or effect plug-in ID
00074 typedef AkUInt32        AkCodecID;                  ///< Codec plug-in ID
00075 typedef AkUInt32        AkAuxBusID;                 ///< Auxilliary bus ID
00076 typedef AkInt16         AkPluginParamID;            ///< Source or effect plug-in parameter ID
00077 typedef AkInt8          AkPriority;                 ///< Priority
00078 typedef AkUInt16        AkDataCompID;               ///< Data compression format ID
00079 typedef AkUInt16        AkDataTypeID;               ///< Data sample type ID
00080 typedef AkUInt8         AkDataInterleaveID;         ///< Data interleaved state ID
00081 typedef AkUInt32        AkSwitchGroupID;            ///< Switch group ID
00082 typedef AkUInt32        AkSwitchStateID;            ///< Switch ID
00083 typedef AkUInt32        AkRtpcID;                   ///< Real time parameter control ID
00084 typedef AkReal32        AkRtpcValue;                ///< Real time parameter control value
00085 typedef AkUInt32        AkBankID;                   ///< Run time bank ID
00086 typedef AkUInt32        AkFileID;                   ///< Integer-type file identifier
00087 typedef AkUInt32        AkDeviceID;                 ///< I/O device ID
00088 typedef AkUInt32        AkTriggerID;                ///< Trigger ID
00089 typedef AkUInt32        AkArgumentValueID;          ///< Argument value ID
00090 typedef AkUInt32        AkChannelMask;              ///< Channel mask (similar to WAVE_FORMAT_EXTENSIBLE). Bit values are defined in AkSpeakerConfig.h.
00091 typedef AkUInt32        AkModulatorID;              ///< Modulator ID
00092 typedef AkUInt32        AkAcousticTextureID;        ///< Acoustic Texture ID
00093 typedef AkUInt32        AkImageSourceID;            ///< Image Source ID
00094 typedef AkUInt64        AkOutputDeviceID;           ///< Audio Output device ID
00095 
00096 // Constants.
00097 static const AkPluginID                 AK_INVALID_PLUGINID                 = (AkPluginID)-1;       ///< Invalid FX ID
00098 static const AkGameObjectID             AK_INVALID_GAME_OBJECT              = (AkGameObjectID)-1;   ///< Invalid game object (may also mean all game objects)
00099 static const AkUniqueID                 AK_INVALID_UNIQUE_ID                =  0;                   ///< Invalid unique 32-bit ID
00100 static const AkRtpcID                   AK_INVALID_RTPC_ID                  =  AK_INVALID_UNIQUE_ID;///< Invalid RTPC ID
00101 static const AkPlayingID                AK_INVALID_PLAYING_ID               =  AK_INVALID_UNIQUE_ID;///< Invalid playing ID
00102 static const AkUInt32                   AK_DEFAULT_SWITCH_STATE             =  0;                   ///< Switch selected if no switch has been set yet
00103 static const AkMemPoolId                AK_INVALID_POOL_ID                  = -1;                   ///< Invalid pool ID
00104 static const AkMemPoolId                AK_DEFAULT_POOL_ID                  = -1;                   ///< Default pool ID, same as AK_INVALID_POOL_ID
00105 static const AkAuxBusID                 AK_INVALID_AUX_ID                   =  AK_INVALID_UNIQUE_ID;///< Invalid auxiliary bus ID (or no Aux bus ID)
00106 static const AkFileID                   AK_INVALID_FILE_ID                  = (AkFileID)-1;         ///< Invalid file ID
00107 static const AkDeviceID                 AK_INVALID_DEVICE_ID                = (AkDeviceID)-1;       ///< Invalid streaming device ID
00108 static const AkBankID                   AK_INVALID_BANK_ID                  =  AK_INVALID_UNIQUE_ID;///< Invalid bank ID
00109 static const AkArgumentValueID          AK_FALLBACK_ARGUMENTVALUE_ID        =  0;                   ///< Fallback argument value ID
00110 static const AkChannelMask              AK_INVALID_CHANNELMASK              =  0;                   ///< Invalid channel mask
00111 static const AkUInt32                   AK_INVALID_OUTPUT_DEVICE_ID         =  AK_INVALID_UNIQUE_ID;///< Invalid Device ID
00112 
00113 // Priority.
00114 static const AkPriority                 AK_DEFAULT_PRIORITY                 =  50;                  ///< Default sound / I/O priority
00115 static const AkPriority                 AK_MIN_PRIORITY                     =  0;                   ///< Minimal priority value [0,100]
00116 static const AkPriority                 AK_MAX_PRIORITY                     =  100;                 ///< Maximal priority value [0,100]
00117 
00118 // Default bank I/O settings.
00119 static const AkPriority                 AK_DEFAULT_BANK_IO_PRIORITY         = AK_DEFAULT_PRIORITY;  ///<  Default bank load I/O priority
00120 static const AkReal32                   AK_DEFAULT_BANK_THROUGHPUT          = 1*1024*1024/1000.f;   ///<  Default bank load throughput (1 Mb/ms)
00121 
00122 // Bank version
00123 static const AkUInt32                   AK_SOUNDBANK_VERSION =              128;                    ///<  Version of the soundbank reader
00124 
00125 /// Standard function call result.
00126 enum AKRESULT
00127 {
00128     AK_NotImplemented           = 0,    ///< This feature is not implemented.
00129     AK_Success                  = 1,    ///< The operation was successful.
00130     AK_Fail                     = 2,    ///< The operation failed.
00131     AK_PartialSuccess           = 3,    ///< The operation succeeded partially.
00132     AK_NotCompatible            = 4,    ///< Incompatible formats
00133     AK_AlreadyConnected         = 5,    ///< The stream is already connected to another node.
00134     AK_NameNotSet               = 6,    ///< Trying to open a file when its name was not set
00135     AK_InvalidFile              = 7,    ///< An unexpected value causes the file to be invalid.
00136     AK_AudioFileHeaderTooLarge  = 8,    ///< The file header is too large.
00137     AK_MaxReached               = 9,    ///< The maximum was reached.
00138     AK_InputsInUsed             = 10,   ///< Inputs are currently used.
00139     AK_OutputsInUsed            = 11,   ///< Outputs are currently used.
00140     AK_InvalidName              = 12,   ///< The name is invalid.
00141     AK_NameAlreadyInUse         = 13,   ///< The name is already in use.
00142     AK_InvalidID                = 14,   ///< The ID is invalid.
00143     AK_IDNotFound               = 15,   ///< The ID was not found.
00144     AK_InvalidInstanceID        = 16,   ///< The InstanceID is invalid.
00145     AK_NoMoreData               = 17,   ///< No more data is available from the source.
00146     AK_NoSourceAvailable        = 18,   ///< There is no child (source) associated with the node.
00147     AK_StateGroupAlreadyExists  = 19,   ///< The StateGroup already exists.
00148     AK_InvalidStateGroup        = 20,   ///< The StateGroup is not a valid channel.
00149     AK_ChildAlreadyHasAParent   = 21,   ///< The child already has a parent.
00150     AK_InvalidLanguage          = 22,   ///< The language is invalid (applies to the Low-Level I/O).
00151     AK_CannotAddItseflAsAChild  = 23,   ///< It is not possible to add itself as its own child.
00152     //AK_TransitionNotFound     = 24,   ///< The transition is not in the list.
00153     //AK_TransitionNotStartable = 25,   ///< Start allowed in the Running and Done states.
00154     //AK_TransitionNotRemovable = 26,   ///< Must not be in the Computing state.
00155     //AK_UsersListFull          = 27,   ///< No one can be added any more, could be AK_MaxReached.
00156     //AK_UserAlreadyInList      = 28,   ///< This user is already there.
00157     AK_UserNotInList            = 29,   ///< This user is not there.
00158     AK_NoTransitionPoint        = 30,   ///< Not in use.
00159     AK_InvalidParameter         = 31,   ///< Something is not within bounds.
00160     AK_ParameterAdjusted        = 32,   ///< Something was not within bounds and was relocated to the nearest OK value.
00161     AK_IsA3DSound               = 33,   ///< The sound has 3D parameters.
00162     AK_NotA3DSound              = 34,   ///< The sound does not have 3D parameters.
00163     AK_ElementAlreadyInList     = 35,   ///< The item could not be added because it was already in the list.
00164     AK_PathNotFound             = 36,   ///< This path is not known.
00165     AK_PathNoVertices           = 37,   ///< Stuff in vertices before trying to start it
00166     AK_PathNotRunning           = 38,   ///< Only a running path can be paused.
00167     AK_PathNotPaused            = 39,   ///< Only a paused path can be resumed.
00168     AK_PathNodeAlreadyInList    = 40,   ///< This path is already there.
00169     AK_PathNodeNotInList        = 41,   ///< This path is not there.
00170     AK_VoiceNotFound            = 42,   ///< Unknown in our voices list
00171     AK_DataNeeded               = 43,   ///< The consumer needs more.
00172     AK_NoDataNeeded             = 44,   ///< The consumer does not need more.
00173     AK_DataReady                = 45,   ///< The provider has available data.
00174     AK_NoDataReady              = 46,   ///< The provider does not have available data.
00175     AK_NoMoreSlotAvailable      = 47,   ///< Not enough space to load bank.
00176     AK_SlotNotFound             = 48,   ///< Bank error.
00177     AK_ProcessingOnly           = 49,   ///< No need to fetch new data.
00178     AK_MemoryLeak               = 50,   ///< Debug mode only.
00179     AK_CorruptedBlockList       = 51,   ///< The memory manager's block list has been corrupted.
00180     AK_InsufficientMemory       = 52,   ///< Memory error.
00181     AK_Cancelled                = 53,   ///< The requested action was cancelled (not an error).
00182     AK_UnknownBankID            = 54,   ///< Trying to load a bank using an ID which is not defined.
00183     AK_IsProcessing             = 55,   ///< Asynchronous pipeline component is processing.
00184     AK_BankReadError            = 56,   ///< Error while reading a bank.
00185     AK_InvalidSwitchType        = 57,   ///< Invalid switch type (used with the switch container)
00186     AK_VoiceDone                = 58,   ///< Internal use only.
00187     AK_UnknownEnvironment       = 59,   ///< This environment is not defined.
00188     AK_EnvironmentInUse         = 60,   ///< This environment is used by an object.
00189     AK_UnknownObject            = 61,   ///< This object is not defined.
00190     AK_NoConversionNeeded       = 62,   ///< Audio data already in target format, no conversion to perform.
00191     AK_FormatNotReady           = 63,   ///< Source format not known yet.
00192     AK_WrongBankVersion         = 64,   ///< The bank version is not compatible with the current bank reader.
00193     AK_DataReadyNoProcess       = 65,   ///< The provider has some data but does not process it (virtual voices).
00194     AK_FileNotFound             = 66,   ///< File not found.
00195     AK_DeviceNotReady           = 67,   ///< IO device not ready (may be because the tray is open)
00196     AK_CouldNotCreateSecBuffer  = 68,   ///< The direct sound secondary buffer creation failed.
00197     AK_BankAlreadyLoaded        = 69,   ///< The bank load failed because the bank is already loaded.
00198     AK_RenderedFX               = 71,   ///< The effect on the node is rendered.
00199     AK_ProcessNeeded            = 72,   ///< A routine needs to be executed on some CPU.
00200     AK_ProcessDone              = 73,   ///< The executed routine has finished its execution.
00201     AK_MemManagerNotInitialized = 74,   ///< The memory manager should have been initialized at this point.
00202     AK_StreamMgrNotInitialized  = 75,   ///< The stream manager should have been initialized at this point.
00203     AK_SSEInstructionsNotSupported = 76,///< The machine does not support SSE instructions (required on PC).
00204     AK_Busy                     = 77,   ///< The system is busy and could not process the request.
00205     AK_UnsupportedChannelConfig = 78,   ///< Channel configuration is not supported in the current execution context.
00206     AK_PluginMediaNotAvailable  = 79,   ///< Plugin media is not available for effect.
00207     AK_MustBeVirtualized        = 80,   ///< Sound was Not Allowed to play.
00208     AK_CommandTooLarge          = 81,   ///< SDK command is too large to fit in the command queue.
00209     AK_RejectedByFilter         = 82,   ///< A play request was rejected due to the MIDI filter parameters.
00210     AK_InvalidCustomPlatformName= 83,   ///< Detecting incompatibility between Custom platform of banks and custom platform of connected application
00211     AK_DLLCannotLoad            = 84,   ///< Plugin DLL could not be loaded, either because it is not found or one dependency is missing.
00212     AK_DLLPathNotFound          = 85,   ///< Plugin DLL search path could not be found.
00213     AK_NoJavaVM                 = 86,   ///< No Java VM provided in AkInitSettings.
00214     AK_OpenSLError              = 87,   ///< OpenSL returned an error.  Check error log for more details.
00215     AK_PluginNotRegistered      = 88,   ///< Plugin is not registered.  Make sure to implement a AK::PluginRegistration class for it and use AK_STATIC_LINK_PLUGIN in the game binary.
00216     AK_DataAlignmentError       = 89,   ///< A pointer to audio data was not aligned to the platform's required alignment (check AkTypes.h in the platform-specific folder)
00217     AK_DuplicateUniqueID        = 90,   ///< Two Wwise objects share the same ID.
00218     AK_InitBankNotLoaded        = 92,   ///< The Init bank was not loaded yet, the sound engine isn't completely ready yet.
00219 };
00220 
00221 /// Game sync group type
00222 enum AkGroupType
00223 {
00224     // should stay set as Switch = 0 and State = 1
00225     AkGroupType_Switch  = 0, ///< Type switch
00226     AkGroupType_State   = 1  ///< Type state
00227 };
00228 
00229 /// This structure allows the game to provide audio files to fill the external sources. See \ref AK::SoundEngine::PostEvent
00230 /// You can specify a streaming file or a file in-memory, regardless of the "Stream" option in the Wwise project.  
00231 /// \akwarning
00232 /// Make sure that only one of szFile, pInMemory or idFile is non-null. if both idFile and szFile are set, idFile is passed to low-level IO and szFile is used as stream name (for profiling purposes).
00233 /// \endakwarning
00234 struct AkExternalSourceInfo
00235 {
00236     AkUInt32 iExternalSrcCookie;    ///< Cookie identifying the source, given by hashing the name of the source given in the project.  See \ref AK::SoundEngine::GetIDFromString. \aknote If an event triggers the playback of more than one external source, they must be named uniquely in the project therefore have a unique cookie) in order to tell them apart when filling the AkExternalSourceInfo structures. \endaknote
00237     AkCodecID idCodec;              ///< Codec ID for the file.  One of the audio formats defined in AkTypes.h (AKCODECID_XXX)
00238     AkOSChar * szFile;              ///< File path for the source.  If not NULL, the source will be streaming from disk.  Set pInMemory to NULL. If idFile is set, this field is used as stream name (for profiling purposes).
00239     void* pInMemory;                ///< Pointer to the in-memory file.  If not NULL, the source will be read from memory.  Set szFile and idFile to NULL.
00240     AkUInt32 uiMemorySize;          ///< Size of the data pointed by pInMemory
00241     AkFileID idFile;                ///< File ID.  If not zero, the source will be streaming from disk.  This ID can be anything.  Note that you must override the low-level IO to resolve this ID to a real file.  See \ref streamingmanager_lowlevel for more information on overriding the Low Level IO.
00242 
00243     /// Default constructor.
00244     AkExternalSourceInfo()
00245         : iExternalSrcCookie( 0 )
00246         , idCodec( 0 )
00247         , szFile( 0 )
00248         , pInMemory( 0 )
00249         , uiMemorySize( 0 )
00250         , idFile( 0 ) {}
00251 
00252     /// Constructor: specify source by memory.
00253     AkExternalSourceInfo( 
00254         void* in_pInMemory,             ///< Pointer to the in-memory file.
00255         AkUInt32 in_uiMemorySize,       ///< Size of data.
00256         AkUInt32 in_iExternalSrcCookie, ///< Cookie.
00257         AkCodecID in_idCodec            ///< Codec ID.
00258         )
00259         : iExternalSrcCookie( in_iExternalSrcCookie )
00260         , idCodec( in_idCodec )
00261         , szFile( 0 )
00262         , pInMemory( in_pInMemory )
00263         , uiMemorySize( in_uiMemorySize )
00264         , idFile( 0 ) {}
00265 
00266     /// Constructor: specify source by streaming file name.
00267     AkExternalSourceInfo( 
00268         AkOSChar * in_pszFileName,      ///< File name.
00269         AkUInt32 in_iExternalSrcCookie, ///< Cookie.
00270         AkCodecID in_idCodec            ///< Codec ID.
00271         )
00272         : iExternalSrcCookie( in_iExternalSrcCookie )
00273         , idCodec( in_idCodec )
00274         , szFile( in_pszFileName )
00275         , pInMemory( 0 )
00276         , uiMemorySize( 0 )
00277         , idFile( 0 ) {}
00278 
00279     /// Constructor: specify source by streaming file ID.
00280     AkExternalSourceInfo( 
00281         AkFileID in_idFile,             ///< File ID.
00282         AkUInt32 in_iExternalSrcCookie, ///< Cookie.
00283         AkCodecID in_idCodec            ///< Codec ID.
00284         )
00285         : iExternalSrcCookie( in_iExternalSrcCookie )
00286         , idCodec( in_idCodec )
00287         , szFile( 0 )
00288         , pInMemory( 0 )
00289         , uiMemorySize( 0 )
00290         , idFile( in_idFile ) {}
00291 };
00292 
00293 /// Nature of the connection binding an input to a bus.
00294 enum AkConnectionType
00295 {
00296     ConnectionType_Direct = 0x0,            ///< Direct (main, dry) connection.
00297     ConnectionType_GameDefSend = 0x1,       ///< Connection by a game-defined send.
00298     ConnectionType_UserDefSend = 0x2,       ///< Connection by a user-defined send.
00299 };
00300 
00301 /// 3D vector.
00302 struct AkVector
00303 {
00304     inline AkVector operator+(const AkVector& b) const
00305     {
00306         AkVector v;
00307 
00308         v.X = X + b.X;
00309         v.Y = Y + b.Y;
00310         v.Z = Z + b.Z;
00311 
00312         return v;
00313     }
00314 
00315     inline void Zero()
00316     {
00317         X = 0; Y = 0; Z = 0;
00318     }
00319 
00320     AkReal32        X;  ///< X Position
00321     AkReal32        Y;  ///< Y Position
00322     AkReal32        Z;  ///< Z Position
00323 };
00324 
00325 /// Position and orientation of game objects.
00326 class AkTransform
00327 {
00328 public:
00329     //
00330     // Getters.
00331     //
00332 
00333     /// Get position vector.
00334     inline const AkVector & Position() const
00335     {
00336         return position;
00337     }
00338 
00339     /// Get orientation front vector.
00340     inline const AkVector & OrientationFront() const
00341     {
00342         return orientationFront;
00343     }
00344 
00345     /// Get orientation top vector.
00346     inline const AkVector & OrientationTop() const
00347     {
00348         return orientationTop;
00349     }
00350 
00351     //
00352     // Setters.
00353     //
00354 
00355     /// Set position and orientation. Orientation front and top should be orthogonal and normalized.
00356     inline void Set(
00357         const AkVector & in_position,           ///< Position vector.
00358         const AkVector & in_orientationFront,   ///< Orientation front
00359         const AkVector & in_orientationTop      ///< Orientation top
00360         )
00361     {
00362         position = in_position;
00363         orientationFront = in_orientationFront;
00364         orientationTop = in_orientationTop;
00365     }
00366 
00367     /// Set position and orientation. Orientation front and top should be orthogonal and normalized.
00368     inline void Set(
00369         AkReal32 in_positionX,                  ///< Position x
00370         AkReal32 in_positionY,                  ///< Position y
00371         AkReal32 in_positionZ,                  ///< Position z
00372         AkReal32 in_orientFrontX,               ///< Orientation front x
00373         AkReal32 in_orientFrontY,               ///< Orientation front y
00374         AkReal32 in_orientFrontZ,               ///< Orientation front z
00375         AkReal32 in_orientTopX,                 ///< Orientation top x
00376         AkReal32 in_orientTopY,                 ///< Orientation top y
00377         AkReal32 in_orientTopZ                  ///< Orientation top z
00378         )
00379     {
00380         position.X = in_positionX;
00381         position.Y = in_positionY;
00382         position.Z = in_positionZ;
00383         orientationFront.X = in_orientFrontX;
00384         orientationFront.Y = in_orientFrontY;
00385         orientationFront.Z = in_orientFrontZ;
00386         orientationTop.X = in_orientTopX;
00387         orientationTop.Y = in_orientTopY;
00388         orientationTop.Z = in_orientTopZ;
00389     }
00390     
00391     /// Set position.
00392     inline void SetPosition(
00393         const AkVector & in_position            ///< Position vector.
00394         )
00395     {
00396         position = in_position;
00397     }
00398 
00399     /// Set position.
00400     inline void SetPosition(
00401         AkReal32 in_x,                          ///< x
00402         AkReal32 in_y,                          ///< y
00403         AkReal32 in_z                           ///< z
00404         )
00405     {
00406         position.X = in_x;
00407         position.Y = in_y;
00408         position.Z = in_z;
00409     }
00410 
00411     /// Set orientation. Orientation front and top should be orthogonal and normalized.
00412     inline void SetOrientation(
00413         const AkVector & in_orientationFront,   ///< Orientation front
00414         const AkVector & in_orientationTop      ///< Orientation top
00415         )
00416     {
00417         orientationFront = in_orientationFront; 
00418         orientationTop = in_orientationTop;
00419     }   
00420 
00421     /// Set orientation. Orientation front and top should be orthogonal and normalized.
00422     inline void SetOrientation(
00423         AkReal32 in_orientFrontX,               ///< Orientation front x
00424         AkReal32 in_orientFrontY,               ///< Orientation front y
00425         AkReal32 in_orientFrontZ,               ///< Orientation front z
00426         AkReal32 in_orientTopX,                 ///< Orientation top x
00427         AkReal32 in_orientTopY,                 ///< Orientation top y
00428         AkReal32 in_orientTopZ                  ///< Orientation top z
00429         )
00430     {
00431         orientationFront.X = in_orientFrontX;
00432         orientationFront.Y = in_orientFrontY;
00433         orientationFront.Z = in_orientFrontZ;
00434         orientationTop.X = in_orientTopX;
00435         orientationTop.Y = in_orientTopY;
00436         orientationTop.Z = in_orientTopZ;
00437     }
00438 
00439 private:
00440     AkVector        orientationFront;   ///< Orientation of the listener
00441     AkVector        orientationTop;     ///< Top orientation of the listener
00442     AkVector        position;           ///< Position of the listener
00443 };
00444 
00445 /// Positioning information for a sound.
00446 typedef AkTransform AkSoundPosition;
00447 
00448 /// Positioning information for a listener.
00449 typedef AkTransform AkListenerPosition;
00450 
00451 /// Obstruction/occlusion pair for a position
00452 struct AkObstructionOcclusionValues
00453 {
00454     AkReal32 occlusion;    ///< OcclusionLevel: [0.0f..1.0f]
00455     AkReal32 obstruction;  ///< ObstructionLevel: [0.0f..1.0f]
00456 };
00457 
00458 /// Positioning information for a sound, with specified subset of its channels.
00459 struct AkChannelEmitter
00460 {
00461     AkTransform     position;       ///< Emitter position.
00462     AkChannelMask   uInputChannels; ///< Channels to which the above position applies.
00463 };
00464 
00465 /// Polar coordinates.
00466 struct AkPolarCoord
00467 {
00468     AkReal32        r;              ///< Norm/distance
00469     AkReal32        theta;          ///< Azimuth
00470 };
00471 
00472 /// Spherical coordinates.
00473 struct AkSphericalCoord : public AkPolarCoord
00474 {
00475     AkReal32        phi;            ///< Elevation
00476 };
00477 
00478 /// Emitter-listener pair: Positioning data pertaining to a single pair of emitter and listener.
00479 class AkEmitterListenerPair
00480 {
00481 public:
00482     /// Constructor.
00483     AkEmitterListenerPair() 
00484         : fDistance( 0.f )
00485         , fEmitterAngle( 0.f )
00486         , fListenerAngle( 0.f )
00487         , fDryMixGain( 1.f )
00488         , fGameDefAuxMixGain( 1.f )
00489         , fUserDefAuxMixGain( 1.f )
00490         , fOcclusion(0.f)
00491         , fObstruction(0.f)
00492         , fSpread(0.f)
00493         , fFocus(0.f)
00494         , uEmitterChannelMask( 0xFFFFFFFF )
00495         , m_uListenerID( 0 )
00496     {
00497     }
00498     /// Destructor.
00499     ~AkEmitterListenerPair() {}
00500 
00501     /// Get distance.
00502     inline AkReal32 Distance() const { return fDistance; }
00503 
00504     /// Get the absolute angle, in radians between 0 and pi, of the emitter's orientation relative to 
00505     /// the line that joins the emitter and the listener.
00506     inline AkReal32 EmitterAngle() const { return fEmitterAngle; }
00507 
00508     /// Get the absolute angle, in radians between 0 and pi, of the listener's orientation relative to
00509     /// the line that joins the emitter and the listener
00510     inline AkReal32 ListenerAngle() const { return fListenerAngle; }
00511 
00512     /// Get the occlusion factor for this emitter-listener pair
00513     inline AkReal32 Occlusion() const { return fOcclusion; }
00514 
00515     /// Get the obstruction factor for this emitter-listener pair
00516     inline AkReal32 Obstruction() const { return fObstruction; }
00517 
00518     /// Get the emitter-listener-pair-specific gain (due to distance and cone attenuation), linear [0,1], for a given connection type.
00519     inline AkReal32 GetGainForConnectionType(AkConnectionType in_eType) const 
00520     {
00521         if (in_eType == ConnectionType_Direct)
00522             return fDryMixGain;
00523         else if (in_eType == ConnectionType_GameDefSend)
00524             return fGameDefAuxMixGain;
00525         else
00526             return fUserDefAuxMixGain;
00527     }
00528 
00529     /// Get listener ID associated with the emitter-listener pair.
00530     inline AkGameObjectID ListenerID() const { return m_uListenerID; }
00531     
00532     AkTransform emitter;                /// Emitter position.
00533     AkReal32 fDistance;                 /// Distance between emitter and listener.
00534     AkReal32 fEmitterAngle;             /// Angle between position vector and emitter orientation.
00535     AkReal32 fListenerAngle;            /// Angle between position vector and listener orientation.
00536     AkReal32 fDryMixGain;               /// Emitter-listener-pair-specific gain (due to distance and cone attenuation) for direct connections.
00537     AkReal32 fGameDefAuxMixGain;        /// Emitter-listener-pair-specific gain (due to distance and cone attenuation) for game-defined send connections.
00538     AkReal32 fUserDefAuxMixGain;        /// Emitter-listener-pair-specific gain (due to distance and cone attenuation) for user-defined send connections.
00539     AkReal32 fOcclusion;                /// Emitter-listener-pair-specific occlusion factor
00540     AkReal32 fObstruction;              /// Emitter-listener-pair-specific obstruction factor
00541     AkReal32 fSpread;                   /// Emitter-listener-pair-specific spread
00542     AkReal32 fFocus;                    /// Emitter-listener-pair-specific focus
00543     AkChannelMask uEmitterChannelMask;  /// Channels of the emitter that apply to this ray.
00544 protected:
00545     AkGameObjectID m_uListenerID;       /// Listener game object ID.
00546 };
00547 
00548 /// Listener information.
00549 struct AkListener
00550 {
00551     AkListener()
00552         : fScalingFactor( 1.0f )
00553         , bSpatialized( true )
00554     {}
00555     AkListenerPosition  position;       /// Listener position (see AK::SoundEngine::SetPosition()).
00556     AkReal32            fScalingFactor; /// Listener scaling factor (see AK::SoundEngine::SetListenerScalingFactor()).
00557     bool                bSpatialized;   /// Whether listener is spatialized or not (see AK::SoundEngine::SetListenerSpatialization()).
00558 };
00559 
00560 // If you modify AkCurveInterpolation, don't forget to modify WAAPI validation schema accordingly.
00561 
00562 /// Curve interpolation types
00563 enum AkCurveInterpolation
00564 {
00565 //DONT GO BEYOND 15! (see below for details)
00566 //Curves from 0 to LastFadeCurve NEED TO BE A MIRROR IMAGE AROUND LINEAR (eg. Log3 is the inverse of Exp3)
00567     AkCurveInterpolation_Log3           = 0, ///< Log3
00568     AkCurveInterpolation_Sine           = 1, ///< Sine
00569     AkCurveInterpolation_Log1           = 2, ///< Log1
00570     AkCurveInterpolation_InvSCurve      = 3, ///< Inversed S Curve
00571     AkCurveInterpolation_Linear         = 4, ///< Linear (Default)
00572     AkCurveInterpolation_SCurve         = 5, ///< S Curve
00573     AkCurveInterpolation_Exp1           = 6, ///< Exp1
00574     AkCurveInterpolation_SineRecip      = 7, ///< Reciprocal of sine curve
00575     AkCurveInterpolation_Exp3           = 8, ///< Exp3
00576     AkCurveInterpolation_LastFadeCurve  = 8, ///< Update this value to reflect last curve available for fades
00577     AkCurveInterpolation_Constant       = 9  ///< Constant ( not valid for fading values )
00578 //DONT GO BEYOND 15! The value is stored on 5 bits,
00579 //but we can use only 4 bits for the actual values, keeping
00580 //the 5th bit at 0 to void problems when the value is
00581 //expanded to 32 bits.
00582 };
00583 #define AKCURVEINTERPOLATION_NUM_STORAGE_BIT 5 ///< Internal storage restriction, for internal use only.
00584 
00585 /// Auxiliary bus sends information per game object per given auxiliary bus.
00586 struct AkAuxSendValue
00587 {
00588     AkGameObjectID listenerID;  ///< Game object ID of the listener associated with this send.
00589     AkAuxBusID auxBusID;        ///< Auxiliary bus ID.
00590     AkReal32 fControlValue;     ///< Value in the range [0.0f:1.0f], send level to auxiliary bus.   
00591 };
00592 
00593 /// Volume ramp specified by end points "previous" and "next".
00594 struct AkRamp
00595 {
00596     AkRamp() : fPrev( 1.f ), fNext( 1.f ) {}
00597     AkRamp( AkReal32 in_fPrev, AkReal32 in_fNext ) : fPrev( in_fPrev ), fNext( in_fNext ) {}
00598     AkRamp & operator*=(const AkRamp& in_rRhs) { fPrev *= in_rRhs.fPrev; fNext *= in_rRhs.fNext; return *this; }
00599 
00600     AkReal32 fPrev;
00601     AkReal32 fNext; 
00602 };
00603 inline AkRamp operator*(const AkRamp& in_rLhs, const AkRamp& in_rRhs) 
00604 {
00605     AkRamp result(in_rLhs);
00606     result *= in_rRhs;
00607     return result;
00608 }
00609 
00610 #ifndef AK_MEMPOOLATTRIBUTES
00611 
00612     /// Memory pool attributes.
00613     /// Block allocation type determines the method used to allocate
00614     /// a memory pool. Block management type determines the
00615     /// method used to manage memory blocks. Note that
00616     /// the list of values in this enum is platform-dependent.
00617     /// \sa
00618     /// - AkMemoryMgr::CreatePool()
00619     /// - AK::Comm::DEFAULT_MEMORY_POOL_ATTRIBUTES
00620     enum AkMemPoolAttributes
00621     {
00622         AkNoAlloc       = 0,    ///< CreatePool will not allocate memory.  You need to allocate the buffer yourself.
00623         AkMalloc        = 1,    ///< CreatePool will use AK::AllocHook() to allocate the memory block.
00624         AkAllocMask     = AkNoAlloc | AkMalloc,                     ///< Block allocation type mask.
00625 
00626         AkFixedSizeBlocksMode   = 1<<3,         ///< Block management type: Fixed-size blocks. Get blocks through GetBlock/ReleaseBlock API.  If not specified, use AkAlloc/AkFree.
00627         AkBlockMgmtMask = AkFixedSizeBlocksMode ///< Block management type mask.
00628     };
00629     #define AK_MEMPOOLATTRIBUTES
00630 
00631 #endif
00632 
00633 namespace AK
00634 {   
00635     /// External allocation hook for the Memory Manager. Called by the Audiokinetic 
00636     /// implementation of the Memory Manager when creating a pool of type AkMalloc.
00637     /// \aknote This needs to be defined by the client. \endaknote
00638     /// \return A pointer to the start of the allocated memory (NULL if the system is out of memory)
00639     /// \sa
00640     /// - \ref memorymanager
00641     /// - AK::FreeHook()
00642     AK_EXTERNFUNC( void *, AllocHook )( 
00643         size_t in_size          ///< Number of bytes to allocate
00644         );
00645 
00646     /// External deallocation hook for the Memory Manager. Called by the Audiokinetic 
00647     /// implementation of the Memory Manager when destroying a pool of type AkMalloc.
00648     /// \aknote This needs to be defined by the client. \endaknote
00649     /// \sa 
00650     /// - \ref memorymanager
00651     /// - AK::AllocHook()
00652     AK_EXTERNFUNC( void, FreeHook )( 
00653         void * in_pMemAddress   ///< Pointer to the start of memory allocated with AllocHook
00654         );
00655 }
00656 
00657 // ---------------------------------------------------------------
00658 // Languages
00659 // ---------------------------------------------------------------
00660 #define AK_MAX_LANGUAGE_NAME_SIZE   (32)
00661 
00662 // ---------------------------------------------------------------
00663 // File Type ID Definitions
00664 // ---------------------------------------------------------------
00665 
00666 // These correspond to IDs specified in the conversion plug-ins' XML
00667 // files. Audio sources persist them to "remember" their format.
00668 // DO NOT CHANGE THEM without talking to someone in charge of persistence!
00669 
00670 // Vendor ID.
00671 #define AKCOMPANYID_AUDIOKINETIC        (0)     ///< Audiokinetic inc.
00672 #define AKCOMPANYID_AUDIOKINETIC_EXTERNAL (1)   ///< Audiokinetic inc.
00673 #define AKCOMPANYID_MCDSP               (256)   ///< McDSP
00674 #define AKCOMPANYID_WAVEARTS            (257)   ///< WaveArts
00675 #define AKCOMPANYID_PHONETICARTS        (258)   ///< Phonetic Arts
00676 #define AKCOMPANYID_IZOTOPE             (259)   ///< iZotope
00677 #define AKCOMPANYID_GENAUDIO            (260)   ///< GenAudio
00678 #define AKCOMPANYID_CRANKCASEAUDIO      (261)   ///< Crankcase Audio
00679 #define AKCOMPANYID_IOSONO              (262)   ///< IOSONO
00680 #define AKCOMPANYID_AUROTECHNOLOGIES    (263)   ///< Auro Technologies
00681 #define AKCOMPANYID_DOLBY               (264)   ///< Dolby
00682 #define AKCOMPANYID_TWOBIGEARS          (265)   ///< Two Big Ears
00683 #define AKCOMPANYID_OCULUS              (266)   ///< Oculus
00684 #define AKCOMPANYID_BLUERIPPLESOUND     (267)   ///< Blue Ripple Sound
00685 #define AKCOMPANYID_ENZIEN              (268)   ///< Enzien Audio
00686 #define AKCOMPANYID_KROTOS              (269)   ///< Krotos (Dehumanizer)
00687 #define AKCOMPANYID_NURULIZE            (270)   ///< Nurulize
00688 #define AKCOMPANYID_SUPERPOWERED        (271)   ///< Super Powered
00689 #define AKCOMPANYID_GOOGLE              (272)   ///< Google
00690 //#define AKCOMPANYID_NVIDIA            (273)   ///< NVIDIA     // Commented out to avoid redefinition, provider is already defining it.
00691 //#define AKCOMPANYID_RESERVED          (274)   ///< Reserved   // Commented out to avoid redefinition, provider is already defining it.
00692 //#define AKCOMPANYID_MICROSOFT         (275)   ///< Microsoft  // Commented out to avoid redefinition, provider is already defining it.
00693 //#define AKCOMPANYID_YAMAHA            (276)   ///< YAMAHA     // Commented out to avoid redefinition, provider is already defining it.
00694 #define AKCOMPANYID_VISISONICS          (277)   ///< Visisonics
00695 
00696 // File/encoding types of Audiokinetic.
00697 #define AKCODECID_BANK                  (0)     ///< Bank encoding
00698 #define AKCODECID_PCM                   (1)     ///< PCM encoding
00699 #define AKCODECID_ADPCM                 (2)     ///< ADPCM encoding
00700 #define AKCODECID_XMA                   (3)     ///< XMA encoding
00701 #define AKCODECID_VORBIS                (4)     ///< Vorbis encoding
00702 #define AKCODECID_WIIADPCM              (5)     ///< ADPCM encoding on the Wii
00703 #define AKCODECID_PCMEX                 (7)     ///< Standard PCM WAV file parser for Wwise Authoring
00704 #define AKCODECID_EXTERNAL_SOURCE       (8)     ///< External Source (unknown encoding)
00705 #define AKCODECID_XWMA                  (9)     ///< xWMA encoding
00706 #define AKCODECID_AAC                   (10)    ///< AAC encoding (only available on Apple devices) -- see AkAACFactory.h
00707 #define AKCODECID_FILE_PACKAGE          (11)    ///< File package files generated by the File Packager utility.
00708 #define AKCODECID_ATRAC9                (12)    ///< ATRAC-9 encoding
00709 #define AKCODECID_VAG                   (13)    ///< VAG/HE-VAG encoding
00710 #define AKCODECID_PROFILERCAPTURE       (14)    ///< Profiler capture file (.prof) as written through AK::SoundEngine::StartProfilerCapture
00711 #define AKCODECID_ANALYSISFILE          (15)    ///< Analysis file
00712 #define AKCODECID_MIDI                  (16)    ///< MIDI file
00713 #define AKCODECID_OPUS                  (17)    ///< Opus encoding
00714 #define AKCODECID_CAF                   (18)    ///< CAF file
00715 
00716 //The following are internally defined
00717 #define AK_WAVE_FORMAT_VAG              0xFFFB
00718 #define AK_WAVE_FORMAT_AT9              0xFFFC
00719 #define AK_WAVE_FORMAT_VORBIS           0xFFFF
00720 #define AK_WAVE_FORMAT_AAC              0xAAC0
00721 #define AK_WAVE_FORMAT_OPUS             0x3039
00722 #define WAVE_FORMAT_XMA2                0x166
00723 
00724 class IAkSoftwareCodec;
00725 /// Registered file source creation function prototype.
00726 AK_CALLBACK( IAkSoftwareCodec*, AkCreateFileSourceCallback )( void* in_pCtx );
00727 /// Registered bank source node creation function prototype.
00728 AK_CALLBACK( IAkSoftwareCodec*, AkCreateBankSourceCallback )( void* in_pCtx );
00729 
00730 //-----------------------------------------------------------------------------
00731 // Positioning
00732 //-----------------------------------------------------------------------------
00733 
00734 namespace AK
00735 {
00736     namespace SoundEngine
00737     {
00738         // If you modify MultiPositionType, don't forget to modify WAAPI validation schema accordingly.
00739 
00740         /// MultiPositionType.
00741         /// \sa
00742         /// - AK::SoundEngine::SetMultiplePosition()
00743         /// - \ref soundengine_3dpositions_multiplepos
00744         enum MultiPositionType
00745         {
00746             MultiPositionType_SingleSource,     ///< Used for normal sounds, not expected to pass to AK::SoundEngine::SetMultiplePosition() (if done, only the first position will be used).
00747             MultiPositionType_MultiSources,     ///< Simulate multiple sources in one sound playing, adding volumes. For instance, all the torches on your level emitting using only one sound.
00748             MultiPositionType_MultiDirections   ///< Simulate one sound coming from multiple directions. Useful for repositionning sounds based on wall openings or to simulate areas like forest or rivers ( in combination with spreading in the attenuation of the sounds ).
00749         };
00750     }
00751 }
00752 
00753 /// 3D Positioning type.
00754 #define PANNER_NUM_STORAGE_BITS 2
00755 enum AkPannerType
00756 {
00757     Ak2D        = 0,    ///< 2D Panner
00758     Ak3D        = 1     ///< 3D Panner
00759 };
00760 
00761 #define POSSOURCE_NUM_STORAGE_BITS 2
00762 enum AkPositionSourceType
00763 {
00764     AkUserDef           = 0,    ///< 3D user-defined
00765     AkGameDef           = 1     ///< 3D game-defined
00766 };
00767 
00768 /// Headphone / speakers panning rules
00769 enum AkPanningRule
00770 {
00771     AkPanningRule_Speakers      = 0,    ///< Left and right positioned 60 degrees apart (by default - see AK::SoundEngine::GetSpeakerAngles()).
00772     AkPanningRule_Headphones    = 1     ///< Left and right positioned 180 degrees apart.
00773 };
00774 
00775 /// 3D spatialization mode.
00776 enum Ak3DSpatializationMode
00777 {
00778     AK_SpatializationMode_None = 0,                     ///< No spatialization
00779     AK_SpatializationMode_PositionOnly = 1,             ///< Spatialization based on emitter position only.
00780     AK_SpatializationMode_PositionAndOrientation = 2    ///< Spatialization based on both emitter position and emitter orientation.
00781 };
00782 
00783 /// Bus type bit field.
00784 enum AkBusHierarchyFlags
00785 {
00786     AkBusHierarchy_Primary      = 1 << 0,   ///< Flag is set to indicate the primary bus hierarchy.
00787     AkBusHierarchy_Secondary    = 1 << 1,   ///< Flag is set to indicate the secondary bus hierarchy.
00788     AkBusHierarchy_IsMaster     = 1 << 7    ///< Flag is set to indicate a master bus (may be used in combination with other flags).
00789 };
00790 
00791 #define AK_MAX_BITS_METERING_FLAGS  (5) // Keep in sync with AkMeteringFlags.
00792 
00793 /// Metering flags. Used for specifying bus metering, through AK::SoundEngine::RegisterBusVolumeCallback() or AK::IAkMixerPluginContext::SetMeteringFlags().
00794 enum AkMeteringFlags
00795 {
00796     AK_NoMetering               = 0,            ///< No metering.
00797     AK_EnableBusMeter_Peak      = 1 << 0,       ///< Enable computation of peak metering.
00798     AK_EnableBusMeter_TruePeak  = 1 << 1,       ///< Enable computation of true peak metering (most CPU and memory intensive).
00799     AK_EnableBusMeter_RMS       = 1 << 2,       ///< Enable computation of RMS metering.
00800     // 1 << 3 is reserved.
00801     AK_EnableBusMeter_KPower    = 1 << 4        ///< Enable computation of K-weighted power metering (used as a basis for computing loudness, as defined by ITU-R BS.1770).
00802 };
00803 
00804 /// Plug-in type.
00805 /// \sa
00806 /// - AkPluginInfo
00807 enum AkPluginType
00808 {
00809     AkPluginTypeNone = 0,   ///< Unknown/invalid plug-in type.
00810     AkPluginTypeCodec = 1,  ///< Compressor/decompressor plug-in (allows support for custom audio file types).
00811     AkPluginTypeSource = 2, ///< Source plug-in: creates sound by synthesis method (no input, just output).
00812     AkPluginTypeEffect = 3, ///< Effect plug-in: applies processing to audio data.
00813     //AkPluginTypeMotionDevice = 4, ///< Motion Device plug-in: feeds movement data to devices. Deprecated by Motion refactor.
00814     //AkPluginTypeMotionSource = 5, ///< Motion Device source plug-in: feeds movement data to device busses. Deprecated by Motion refactor.
00815     AkPluginTypeMixer = 6,  ///< Mixer plug-in: mix voices at the bus level.
00816     AkPluginTypeSink = 7,   ///< Sink plug-in: implement custom sound engine end point.
00817     AkPluginTypeMask = 0xf  ///< Plug-in type mask is 4 bits.
00818 };
00819 
00820 ////////////////////////////////////////////////////////////////////////////////
00821 // Wwise ID system
00822 ////////////////////////////////////////////////////////////////////////////////
00823 enum AkNodeType
00824 {
00825     AkNodeType_Default,
00826     AkNodeType_Bus
00827 };
00828 
00829 struct WwiseObjectIDext
00830 {
00831 public:
00832 
00833     bool operator == ( const WwiseObjectIDext& in_rOther ) const
00834     {
00835         return in_rOther.id == id && in_rOther.bIsBus == bIsBus;
00836     }
00837 
00838     AkNodeType GetType()
00839     {
00840         return bIsBus ? AkNodeType_Bus : AkNodeType_Default;
00841     }
00842 
00843     AkUniqueID  id;
00844     bool        bIsBus;
00845 };
00846 
00847 struct WwiseObjectID : public WwiseObjectIDext
00848 {
00849     WwiseObjectID()
00850     {
00851         id = AK_INVALID_UNIQUE_ID;
00852         bIsBus = false;
00853     }
00854 
00855     WwiseObjectID( AkUniqueID in_ID )
00856     {
00857         id = in_ID;
00858         bIsBus = false;
00859     }
00860 
00861     WwiseObjectID( AkUniqueID in_ID, bool in_bIsBus )
00862     {
00863         id = in_ID;
00864         bIsBus = in_bIsBus;
00865     }
00866 
00867     WwiseObjectID( AkUniqueID in_ID, AkNodeType in_eNodeType )
00868     {
00869         id = in_ID;
00870         bIsBus = in_eNodeType == AkNodeType_Bus;
00871     }
00872 };
00873 
00874 /// Public data structures for converted file format.
00875 namespace AkFileParser
00876 {
00877 #pragma pack(push, 1)
00878     /// Analyzed envelope point.
00879     struct EnvelopePoint
00880     {
00881         AkUInt32 uPosition;     /// Position of this point in samples at the source rate.
00882         AkUInt16 uAttenuation;  /// Approximate _attenuation_ at this location relative to this source's maximum, in dB (absolute value).
00883     };
00884 #pragma pack(pop)
00885 }
00886 
00887 #ifndef AK_OS_STRUCT_ALIGN
00888 #define AK_OS_STRUCT_ALIGN  4               ///< OS Structures need to be aligned at 4 bytes.
00889 #endif
00890 
00891 #ifndef AK_64B_OS_STRUCT_ALIGN
00892 #define AK_64B_OS_STRUCT_ALIGN  8               ///< OS Structures need to be aligned at 8 bytes.
00893 #endif
00894 
00895 #ifndef AK_ALIGN
00896 #define AK_ALIGN(__declaration__, uAlignmentSize) __declaration__ ///< Default definition for declaration that might need to be aligned on some platforms. By default, no alignment will be done.
00897 #endif
00898 
00899 #if !defined(AK_ENDIANNESS_LITTLE) && !defined(AK_ENDIANNESS_BIG)
00900 #define AK_ENDIANNESS_LITTLE
00901 #endif
00902 
00903 #ifndef AK_UNALIGNED
00904 #define AK_UNALIGNED                        ///< Refers to the __unaligned compilation flag available on some platforms. Note that so far, on the tested platform this should always be placed before the pointer symbol *.
00905 #endif
00906 
00907 #ifndef AK_FINAL
00908 #define AK_FINAL
00909 #endif
00910 
00911 #ifndef AK_ASYNC_OPEN_DEFAULT
00912 #define AK_ASYNC_OPEN_DEFAULT   (false)             ///< Refers to asynchronous file opening in default low-level IO.
00913 #endif
00914 
00915 #ifndef AK_COMM_DEFAULT_DISCOVERY_PORT
00916 #define AK_COMM_DEFAULT_DISCOVERY_PORT 24024    ///< Default discovery port for most platforms using IP sockets for communication.
00917 #endif
00918 
00919 #ifndef AK_CAPTURE_TYPE_FLOAT
00920 typedef AkInt16     AkCaptureType;          ///< Default value: capture type is short.
00921 #endif
00922 
00923 #define AkRegister
00924 
00925 #endif  //_AK_DATA_TYPES_H_

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.

Register your project and we'll help you get started with no strings attached!

Get started with Wwise