_ak_speaker_volumes_8h

Wwise SDK 2025.1.2

 /*******************************************************************************
 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.
 *******************************************************************************/
  
 // AkSpeakerVolumes.h
  
 /// \file 
 /// Multi-channel volume definitions and services.
 /// Always associated with an AkChannelConfig. In the case of standard configurations, the volume items ordering
 /// match the bit ordering in the channel mask, except for the LFE which is skipped and placed at the end of the
 /// volume array.
 /// See \ref goingfurther_speakermatrixcallback for an example of how to manipulate speaker volume vectors/matrices.
  
 #ifndef _AK_SPEAKER_VOLUMES_H_
 #define _AK_SPEAKER_VOLUMES_H_
  
 #include <string.h>
 #include <AK/SoundEngine/Common/AkTypes.h>
  
 #ifdef __cplusplus
  
 #include <AK/SoundEngine/Platforms/Generic/AkSpeakerVolumes.h>
  
 extern "C" {
 #endif
  
 /// Copy volumes.
 /// 
 /// \param[out] out_pVolumesDst Pointer to destination volume vector.
 /// \param[in] in_pVolumesSrc Pointer to source volume vector.
 /// \param[in] in_uNumChannels Number of channels.
 AK_EXTERNAPIFUNC(void, AK_SpeakerVolumes_Vector_Copy)(AkSpeakerVolumesVectorPtr out_pVolumesDst, AkSpeakerVolumesConstVectorPtr in_pVolumesSrc, AkUInt32 in_uNumChannels);
  
 /// Copy volumes with gain.
 /// 
 /// \param[out] out_pVolumesDst Pointer to destination volume vector.
 /// \param[in] in_pVolumesSrc Pointer to source volume vector.
 /// \param[in] in_uNumChannels Number of channels.
 /// \param[in] in_fGain Gain to apply.
 AK_EXTERNAPIFUNC(void, AK_SpeakerVolumes_Vector_CopyAndApplyGain)(AkSpeakerVolumesVectorPtr out_pVolumesDst, AkSpeakerVolumesConstVectorPtr in_pVolumesSrc, AkUInt32 in_uNumChannels, AkReal32 in_fGain);
  
 /// Clear volumes.
 /// 
 /// \param[out] out_pVolumesDst Pointer to volume vector.
 /// \param[in] in_uNumChannels Number of channels.
 AK_EXTERNAPIFUNC(void, AK_SpeakerVolumes_Vector_Zero)(AkSpeakerVolumesVectorPtr out_pVolumesDst, AkUInt32 in_uNumChannels);
  
 /// Accumulate two volume vectors.
 /// 
 /// \param[in,out] io_pVolumesDst Pointer to first and destination vector.
 /// \param[in] in_pVolumesSrc Pointer to second vector.
 /// \param[in] in_uNumChannels Number of channels.
 AK_EXTERNAPIFUNC(void, AK_SpeakerVolumes_Vector_Add)(AkSpeakerVolumesVectorPtr io_pVolumesDst, AkSpeakerVolumesConstVectorPtr in_pVolumesSrc, AkUInt32 in_uNumChannels);
  
 /// Compute the sum of all components of a volume vector.
 /// 
 /// \param[in] in_pVolumes Pointer to volume vector.
 /// \param[in] in_uNumChannels Number of channels.
 /// \return The sum of all volumes.
 AK_EXTERNAPIFUNC(AkReal32, AK_SpeakerVolumes_Vector_L1Norm)(AkSpeakerVolumesConstVectorPtr in_pVolumes, AkUInt32 in_uNumChannels);
  
 /// Multiply volume vector with a scalar.
 /// 
 /// \param[in,out] io_pVolumesDst Pointer to volume vector.
 /// \param[in] in_fVol Volume multiplier.
 /// \param[in] in_uNumChannels Number of channels.
 AK_EXTERNAPIFUNC(void, AK_SpeakerVolumes_Vector_MulScalar)(AkSpeakerVolumesVectorPtr io_pVolumesDst, AkReal32 in_fVol, AkUInt32 in_uNumChannels);
  
 /// Multiply two volume vectors.
 ///
 /// \param[in,out] io_pVolumesDst Pointer to first and destination vector.
 /// \param[in] in_pVolumesSrc Pointer to second vector.
 /// \param[in] in_uNumChannels Number of channels.
 AK_EXTERNAPIFUNC(void, AK_SpeakerVolumes_Vector_Mul)(AkSpeakerVolumesVectorPtr io_pVolumesDst, AkSpeakerVolumesConstVectorPtr in_pVolumesSrc, AkUInt32 in_uNumChannels);
  
 /// Get max for all elements of two volume vectors, independently.
 /// 
 /// \param[in,out] io_pVolumesDst Pointer to first and destination vector.
 /// \param[in] in_pVolumesSrc Pointer to second vector.
 /// \param[in] in_uNumChannels Number of channels.
 AK_EXTERNAPIFUNC(void, AK_SpeakerVolumes_Vector_Max)(AkSpeakerVolumesVectorPtr io_pVolumesDst, AkSpeakerVolumesConstVectorPtr in_pVolumesSrc, AkUInt32 in_uNumChannels);
  
 /// Get min for all elements of two volume vectors, independently.
 /// 
 /// \param[in,out] io_pVolumesDst Pointer to first and destination vector.
 /// \param[in] in_pVolumesSrc Pointer to second vector.
 /// \param[in] in_uNumChannels Number of channels.
 AK_EXTERNAPIFUNC(void, AK_SpeakerVolumes_Vector_Min)(AkSpeakerVolumesVectorPtr io_pVolumesDst, AkSpeakerVolumesConstVectorPtr in_pVolumesSrc, AkUInt32 in_uNumChannels);
  
 /// Compute size (in number of elements/floats) required for given number of channels in vector.
 /// 
 /// \param[in] in_uNumChannels Number of channels.
 AK_EXTERNAPIFUNC(AkUInt32, AK_SpeakerVolumes_Vector_GetNumElements)(AkUInt32 in_uNumChannels);
  
 /// Compute size (in bytes) required for given number of channels in vector.
 /// 
 /// \param[in] in_uNumChannels Number of channels.
 AK_EXTERNAPIFUNC(AkUInt32, AK_SpeakerVolumes_Vector_GetRequiredSize)(AkUInt32 in_uNumChannels);
  
 /// Compute matrix size required for given channel configurations.
 /// 
 /// \param[in] in_uNumChannelsIn Number of input channels.
 /// \param[in] in_uNumChannelsOut Number of output channels.
 /// \return Matrix size in byte.
 AK_EXTERNAPIFUNC(AkUInt32, AK_SpeakerVolumes_Matrix_GetRequiredSize)(AkUInt32 in_uNumChannelsIn, AkUInt32 in_uNumChannelsOut);
  
 /// Compute number of elements in matrix required for given channel configurations.
 /// 
 /// \param[in] in_uNumChannelsIn Number of input channels.
 /// \param[in] in_uNumChannelsOut Number of output channels.
 /// \return Number of matrix elements.
 AK_EXTERNAPIFUNC(AkUInt32, AK_SpeakerVolumes_Matrix_GetNumElements)(AkUInt32 in_uNumChannelsIn, AkUInt32 in_uNumChannelsOut);
  
 /// Get pointer to volume distribution for input channel in_uIdxChannelIn.
 /// 
 /// \param[in] in_pVolumeMx Pointer to volume matrix.
 /// \param[in] in_uIdxChannelIn Index of input channels.
 /// \param[in] in_uNumChannelsOut Number of output channels.
 /// \return Pointer to volume distribution vector.
 AK_EXTERNAPIFUNC(AkSpeakerVolumesVectorPtr, AK_SpeakerVolumes_Matrix_GetChannel)(AkSpeakerVolumesMatrixPtr in_pVolumeMx, AkUInt32 in_uIdxChannelIn, AkUInt32 in_uNumChannelsOut);
  
 /// Get pointer to volume distribution for input channel in_uIdxChannelIn.
 /// 
 /// \param[in] in_pVolumeMx Pointer to volume matrix.
 /// \param[in] in_uIdxChannelIn Index of input channels.
 /// \param[in] in_uNumChannelsOut Number of output channels.
 /// \return Pointer to volume distribution vector.
 AK_EXTERNAPIFUNC(AkSpeakerVolumesConstVectorPtr, AK_SpeakerVolumes_Matrix_GetChannel_Const)(AkSpeakerVolumesConstMatrixPtr in_pVolumeMx, AkUInt32 in_uIdxChannelIn, AkUInt32 in_uNumChannelsOut);
  
 /// Copy matrix.
 /// 
 /// \param[out] out_pVolumesDst Pointer to destination volume matrix.
 /// \param[in] in_pVolumesSrc Pointer to source volume matrix.
 /// \param[in] in_uNumChannelsIn Number of input channels.
 /// \param[in] in_uNumChannelsOut Number of output channels.
 AK_EXTERNAPIFUNC(void, AK_SpeakerVolumes_Matrix_Copy)(AkSpeakerVolumesMatrixPtr out_pVolumesDst, AkSpeakerVolumesConstMatrixPtr in_pVolumesSrc, AkUInt32 in_uNumChannelsIn, AkUInt32 in_uNumChannelsOut);
  
 /// Copy matrix with gain.
 /// 
 /// \param[out] out_pVolumesDst Pointer to destination volume matrix.
 /// \param[in] in_pVolumesSrc Pointer to source volume matrix.
 /// \param[in] in_uNumChannelsIn Number of input channels.
 /// \param[in] in_uNumChannelsOut Number of output channels.
 /// \param[in] in_fGain Gain to apply.
 AK_EXTERNAPIFUNC(void, AK_SpeakerVolumes_Matrix_CopyAndApplyGain)(AkSpeakerVolumesMatrixPtr out_pVolumesDst, AkSpeakerVolumesConstMatrixPtr in_pVolumesSrc, AkUInt32 in_uNumChannelsIn, AkUInt32 in_uNumChannelsOut, AkReal32 in_fGain);
  
 /// Clear matrix.
 /// 
 /// \param[out] out_pVolumesDst Pointer to destination volume matrix.
 /// \param[in] in_uNumChannelsIn Number of input channels.
 /// \param[in] in_uNumChannelsOut Number of output channels.
 AK_EXTERNAPIFUNC(void, AK_SpeakerVolumes_Matrix_Zero)(AkSpeakerVolumesMatrixPtr out_pVolumesDst, AkUInt32 in_uNumChannelsIn, AkUInt32 in_uNumChannelsOut);
  
 /// Multiply a matrix with a scalar.
 /// 
 /// \param[in,out] io_pVolumesDst Pointer to volume matrix.
 /// \param[in] in_fVol Volume multiplier.
 /// \param[in] in_uNumChannelsIn Number of input channels.
 /// \param[in] in_uNumChannelsOut Number of output channels.
 AK_EXTERNAPIFUNC(void, AK_SpeakerVolumes_Matrix_Mul)(AkSpeakerVolumesMatrixPtr io_pVolumesDst, AkReal32 in_fVol, AkUInt32 in_uNumChannelsIn, AkUInt32 in_uNumChannelsOut);
  
 /// Add all elements of two volume matrices, independently.
 /// 
 /// \param[in,out] io_pVolumesDst Pointer to first and destination volume matrix.
 /// \param[in] in_pVolumesSrc Pointer to second volume matrix.
 /// \param[in] in_uNumChannelsIn Number of input channels.
 /// \param[in] in_uNumChannelsOut Number of output channels.
 AK_EXTERNAPIFUNC(void, AK_SpeakerVolumes_Matrix_Add)(AkSpeakerVolumesMatrixPtr io_pVolumesDst, AkSpeakerVolumesConstMatrixPtr in_pVolumesSrc, AkUInt32 in_uNumChannelsIn, AkUInt32 in_uNumChannelsOut);
  
 /// Pointwise Multiply-Add of all elements of two volume matrices.
 /// 
 /// \param[in,out] io_pVolumesDst Pointer to first and destination volume matrix.
 /// \param[in] in_pVolumesSrc Pointer to second volume matrix.
 /// \param[in] in_uNumChannelsIn Number of input channels.
 /// \param[in] in_uNumChannelsOut Number of output channels.
 /// \param[in] in_fGain Volume multiplier.
 AK_EXTERNAPIFUNC(void, AK_SpeakerVolumes_Matrix_MAdd)(AkSpeakerVolumesMatrixPtr io_pVolumesDst, AkSpeakerVolumesConstMatrixPtr in_pVolumesSrc, AkUInt32 in_uNumChannelsIn, AkUInt32 in_uNumChannelsOut, AkReal32 in_fGain);
  
 /// Get absolute max for all elements of two volume matrices, independently.
 /// 
 /// \param[in,out] io_pVolumesDst Pointer to first and destination volume matrix.
 /// \param[in] in_pVolumesSrc Pointer to second volume matrix.
 /// \param[in] in_uNumChannelsIn Number of input channels.
 /// \param[in] in_uNumChannelsOut Number of output channels.
 AK_EXTERNAPIFUNC(void, AK_SpeakerVolumes_Matrix_AbsMax)(AkSpeakerVolumesMatrixPtr io_pVolumesDst, AkSpeakerVolumesConstMatrixPtr in_pVolumesSrc, AkUInt32 in_uNumChannelsIn, AkUInt32 in_uNumChannelsOut);
  
 /// Get max for all elements of two volume matrices, independently.
 /// 
 /// \param[in,out] io_pVolumesDst Pointer to first and destination volume matrix.
 /// \param[in] in_pVolumesSrc Pointer to second volume matrix.
 /// \param[in] in_uNumChannelsIn Number of input channels.
 /// \param[in] in_uNumChannelsOut Number of output channels.
 AK_EXTERNAPIFUNC(void, AK_SpeakerVolumes_Matrix_Max)(AkSpeakerVolumesMatrixPtr io_pVolumesDst, AkSpeakerVolumesConstMatrixPtr in_pVolumesSrc, AkUInt32 in_uNumChannelsIn, AkUInt32 in_uNumChannelsOut);
  
 #ifdef __cplusplus
 } // extern "C"
  
 namespace AK
 {
 /// Multi-channel volume definitions and services.
 namespace SpeakerVolumes
 {
     /// Volume vector services.
     namespace Vector
     {
         AkForceInline void Copy(VectorPtr in_pVolumesDst, ConstVectorPtr in_pVolumesSrc, AkUInt32 in_uNumChannels)
         {
             if (in_uNumChannels)
                 memcpy(in_pVolumesDst, in_pVolumesSrc, in_uNumChannels * sizeof(AkReal32));
         }
  
         AkForceInline void Copy(VectorPtr in_pVolumesDst, ConstVectorPtr in_pVolumesSrc, AkUInt32 in_uNumChannels, AkReal32 in_fGain)
         {
             for (AkUInt32 uChan = 0; uChan < in_uNumChannels; uChan++)
             {
                 in_pVolumesDst[uChan] = in_pVolumesSrc[uChan] * in_fGain;
             }
         }
  
         AkForceInline void Zero(VectorPtr in_pVolumes, AkUInt32 in_uNumChannels)
         {
             if (in_uNumChannels)
                 memset(in_pVolumes, 0, in_uNumChannels * sizeof(AkReal32));
         }
  
         AkForceInline void Add(VectorPtr in_pVolumesDst, ConstVectorPtr in_pVolumesSrc, AkUInt32 in_uNumChannels)
         {
             for (AkUInt32 uChan = 0; uChan < in_uNumChannels; uChan++)
             {
                 in_pVolumesDst[uChan] += in_pVolumesSrc[uChan];
             }
         }
  
         AkForceInline AkReal32 L1Norm(ConstVectorPtr io_pVolumes, AkUInt32 in_uNumChannels)
         {
             AkReal32 total = 0;
             for (AkUInt32 uChan = 0; uChan < in_uNumChannels; uChan++)
             {
                 total += io_pVolumes[uChan];
             }
  
             return total;
         }
  
         AkForceInline void Mul(VectorPtr in_pVolumesDst, const AkReal32 in_fVol, AkUInt32 in_uNumChannels)
         {
             for (AkUInt32 uChan = 0; uChan < in_uNumChannels; uChan++)
             {
                 in_pVolumesDst[uChan] *= in_fVol;
             }
         }
  
         AkForceInline void Mul(VectorPtr in_pVolumesDst, ConstVectorPtr in_pVolumesSrc, AkUInt32 in_uNumChannels)
         {
             for (AkUInt32 uChan = 0; uChan < in_uNumChannels; uChan++)
             {
                 in_pVolumesDst[uChan] *= in_pVolumesSrc[uChan];
             }
         }
  
         AkForceInline void Max(AkReal32* in_pVolumesDst, const AkReal32* in_pVolumesSrc, AkUInt32 in_uNumChannels)
         {
             for (AkUInt32 uChan = 0; uChan < in_uNumChannels; uChan++)
             {
                 in_pVolumesDst[uChan] = AkMax(in_pVolumesDst[uChan], in_pVolumesSrc[uChan]);
             }
         }
  
         AkForceInline void Min(AkReal32* in_pVolumesDst, const AkReal32* in_pVolumesSrc, AkUInt32 in_uNumChannels)
         {
             for (AkUInt32 uChan = 0; uChan < in_uNumChannels; uChan++)
             {
                 in_pVolumesDst[uChan] = AkMin(in_pVolumesDst[uChan], in_pVolumesSrc[uChan]);
             }
         }
     }
  
     /// Volume matrix (multi-in/multi-out channel configurations) services.
     namespace Matrix
     {
         AkForceInline AkUInt32 GetRequiredSize(AkUInt32 in_uNumChannelsIn, AkUInt32 in_uNumChannelsOut)
         {
             return in_uNumChannelsIn * Vector::GetRequiredSize(in_uNumChannelsOut);
         }
  
         AkForceInline AkUInt32 GetNumElements(AkUInt32 in_uNumChannelsIn, AkUInt32 in_uNumChannelsOut)
         {
             return in_uNumChannelsIn * Vector::GetNumElements(in_uNumChannelsOut);
         }
  
         AkForceInline VectorPtr GetChannel(MatrixPtr in_pVolumeMx, AkUInt32 in_uIdxChannelIn, AkUInt32 in_uNumChannelsOut)
         {
             return in_pVolumeMx + in_uIdxChannelIn * Vector::GetNumElements(in_uNumChannelsOut);
         }
  
         AkForceInline ConstVectorPtr GetChannel(ConstMatrixPtr in_pVolumeMx, AkUInt32 in_uIdxChannelIn, AkUInt32 in_uNumChannelsOut)
         {
             return in_pVolumeMx + in_uIdxChannelIn * Vector::GetNumElements(in_uNumChannelsOut);
         }
  
         AkForceInline void Copy(MatrixPtr in_pVolumesDst, ConstMatrixPtr in_pVolumesSrc, AkUInt32 in_uNumChannelsIn, AkUInt32 in_uNumChannelsOut)
         {
             AkUInt32 uNumElements = Matrix::GetNumElements(in_uNumChannelsIn, in_uNumChannelsOut);
             if (uNumElements)
                 memcpy(in_pVolumesDst, in_pVolumesSrc, uNumElements * sizeof(AkReal32));
         }
  
         AkForceInline void Copy(MatrixPtr in_pVolumesDst, ConstMatrixPtr in_pVolumesSrc, AkUInt32 in_uNumChannelsIn, AkUInt32 in_uNumChannelsOut, AkReal32 in_fGain)
         {
             AkUInt32 uNumElements = Matrix::GetNumElements(in_uNumChannelsIn, in_uNumChannelsOut);
             for (AkUInt32 uChan = 0; uChan < uNumElements; uChan++)
             {
                 in_pVolumesDst[uChan] = in_pVolumesSrc[uChan] * in_fGain;
             }
         }
  
         AkForceInline void Zero(MatrixPtr in_pVolumes, AkUInt32 in_uNumChannelsIn, AkUInt32 in_uNumChannelsOut)
         {
             AkUInt32 uNumElements = Matrix::GetNumElements(in_uNumChannelsIn, in_uNumChannelsOut);
             if (uNumElements)
                 memset(in_pVolumes, 0, uNumElements * sizeof(AkReal32));
         }
  
         AkForceInline void Mul(MatrixPtr in_pVolumesDst, const AkReal32 in_fVol, AkUInt32 in_uNumChannelsIn, AkUInt32 in_uNumChannelsOut)
         {
             AkUInt32 uNumElements = Matrix::GetNumElements(in_uNumChannelsIn, in_uNumChannelsOut);
             for (AkUInt32 uChan = 0; uChan < uNumElements; uChan++)
             {
                 in_pVolumesDst[uChan] *= in_fVol;
             }
         }
  
         AkForceInline void Add(MatrixPtr in_pVolumesDst, ConstMatrixPtr in_pVolumesSrc, AkUInt32 in_uNumChannelsIn, AkUInt32 in_uNumChannelsOut)
         {
             AkUInt32 uNumElements = Matrix::GetNumElements(in_uNumChannelsIn, in_uNumChannelsOut);
             for (AkUInt32 uChan = 0; uChan < uNumElements; uChan++)
             {
                 in_pVolumesDst[uChan] += in_pVolumesSrc[uChan];
             }
         }
  
         AkForceInline void MAdd(MatrixPtr in_pVolumesDst, ConstMatrixPtr in_pVolumesSrc, AkUInt32 in_uNumChannelsIn, AkUInt32 in_uNumChannelsOut, AkReal32 in_fGain)
         {
             AkUInt32 uNumElements = Matrix::GetNumElements(in_uNumChannelsIn, in_uNumChannelsOut);
             for (AkUInt32 uChan = 0; uChan < uNumElements; uChan++)
             {
                 in_pVolumesDst[uChan] += in_pVolumesSrc[uChan] * in_fGain;
             }
         }
  
         AkForceInline void AbsMax(MatrixPtr in_pVolumesDst, ConstMatrixPtr in_pVolumesSrc, AkUInt32 in_uNumChannelsIn, AkUInt32 in_uNumChannelsOut)
         {
             AkUInt32 uNumElements = Matrix::GetNumElements(in_uNumChannelsIn, in_uNumChannelsOut);
             for (AkUInt32 uChan = 0; uChan < uNumElements; uChan++)
             {
                 in_pVolumesDst[uChan] = ((in_pVolumesDst[uChan] * in_pVolumesDst[uChan]) > (in_pVolumesSrc[uChan] * in_pVolumesSrc[uChan])) ? in_pVolumesDst[uChan] : in_pVolumesSrc[uChan];
             }
         }
  
         AkForceInline void Max(MatrixPtr in_pVolumesDst, ConstMatrixPtr in_pVolumesSrc, AkUInt32 in_uNumChannelsIn, AkUInt32 in_uNumChannelsOut)
         {
             AkUInt32 uNumElements = Matrix::GetNumElements(in_uNumChannelsIn, in_uNumChannelsOut);
             for (AkUInt32 uChan = 0; uChan < uNumElements; uChan++)
             {
                 in_pVolumesDst[uChan] = (in_pVolumesDst[uChan] > in_pVolumesSrc[uChan]) ? in_pVolumesDst[uChan] : in_pVolumesSrc[uChan];
             }
         }
     }
 }
 }
 #endif // __cplusplus
  
 #endif  //_AK_SPEAKER_VOLUMES_H_

AK_SpeakerVolumes_Matrix_Mul

AKSOUNDENGINE_API void AK_SpeakerVolumes_Matrix_Mul(AkSpeakerVolumesMatrixPtr io_pVolumesDst, AkReal32 in_fVol, AkUInt32 in_uNumChannelsIn, AkUInt32 in_uNumChannelsOut)

AK::SpeakerVolumes::Vector::Copy

AkForceInline void Copy(VectorPtr in_pVolumesDst, ConstVectorPtr in_pVolumesSrc, AkUInt32 in_uNumChannels)

Definition: AkSpeakerVolumes.h:228

AkMax

#define AkMax(x1, x2)

Definition: AkSoundEngineTypes.h:45

Definition of data structures for AkAudioObject

Definition: AkWwiseSDKVersion.cs:31

AK_SpeakerVolumes_Vector_GetNumElements

AKSOUNDENGINE_API AkUInt32 AK_SpeakerVolumes_Vector_GetNumElements(AkUInt32 in_uNumChannels)

AkSpeakerVolumesMatrixPtr

AkReal32 * AkSpeakerVolumesMatrixPtr

Definition: AkTypedefs.h:83

AK::SpeakerVolumes::Vector::L1Norm

AkForceInline AkReal32 L1Norm(ConstVectorPtr io_pVolumes, AkUInt32 in_uNumChannels)

Definition: AkSpeakerVolumes.h:256

AK::SpeakerVolumes::Vector::Max

AkForceInline void Max(AkReal32 *in_pVolumesDst, const AkReal32 *in_pVolumesSrc, AkUInt32 in_uNumChannels)

Definition: AkSpeakerVolumes.h:283

AK_SpeakerVolumes_Matrix_AbsMax

AKSOUNDENGINE_API void AK_SpeakerVolumes_Matrix_AbsMax(AkSpeakerVolumesMatrixPtr io_pVolumesDst, AkSpeakerVolumesConstMatrixPtr in_pVolumesSrc, AkUInt32 in_uNumChannelsIn, AkUInt32 in_uNumChannelsOut)

AK_SpeakerVolumes_Matrix_CopyAndApplyGain

AKSOUNDENGINE_API void AK_SpeakerVolumes_Matrix_CopyAndApplyGain(AkSpeakerVolumesMatrixPtr out_pVolumesDst, AkSpeakerVolumesConstMatrixPtr in_pVolumesSrc, AkUInt32 in_uNumChannelsIn, AkUInt32 in_uNumChannelsOut, AkReal32 in_fGain)

AK_EXTERNAPIFUNC

#define AK_EXTERNAPIFUNC(_type, _name)

Definition: AkSoundEngineExport.h:81

AK::SpeakerVolumes::Matrix::GetRequiredSize

AkForceInline AkUInt32 GetRequiredSize(AkUInt32 in_uNumChannelsIn, AkUInt32 in_uNumChannelsOut)

Definition: AkSpeakerVolumes.h:303

AK_SpeakerVolumes_Matrix_Copy

AKSOUNDENGINE_API void AK_SpeakerVolumes_Matrix_Copy(AkSpeakerVolumesMatrixPtr out_pVolumesDst, AkSpeakerVolumesConstMatrixPtr in_pVolumesSrc, AkUInt32 in_uNumChannelsIn, AkUInt32 in_uNumChannelsOut)

AK::SpeakerVolumes::Matrix::Zero

AkForceInline void Zero(MatrixPtr in_pVolumes, AkUInt32 in_uNumChannelsIn, AkUInt32 in_uNumChannelsOut)

Definition: AkSpeakerVolumes.h:339

AK::SpeakerVolumes::Matrix::GetNumElements

AkForceInline AkUInt32 GetNumElements(AkUInt32 in_uNumChannelsIn, AkUInt32 in_uNumChannelsOut)

Definition: AkSpeakerVolumes.h:308

AK_SpeakerVolumes_Vector_L1Norm

AKSOUNDENGINE_API AkReal32 AK_SpeakerVolumes_Vector_L1Norm(AkSpeakerVolumesConstVectorPtr in_pVolumes, AkUInt32 in_uNumChannels)

AK_SpeakerVolumes_Vector_GetRequiredSize

AKSOUNDENGINE_API AkUInt32 AK_SpeakerVolumes_Vector_GetRequiredSize(AkUInt32 in_uNumChannels)

AkReal32

float AkReal32

32-bit floating point

Definition: AkNumeralTypes.h:43

AK::SpeakerVolumes::Matrix::AbsMax

AkForceInline void AbsMax(MatrixPtr in_pVolumesDst, ConstMatrixPtr in_pVolumesSrc, AkUInt32 in_uNumChannelsIn, AkUInt32 in_uNumChannelsOut)

Definition: AkSpeakerVolumes.h:373

AkMin

#define AkMin(x1, x2)

Definition: AkSoundEngineTypes.h:46

AK_SpeakerVolumes_Vector_Zero

AKSOUNDENGINE_API void AK_SpeakerVolumes_Vector_Zero(AkSpeakerVolumesVectorPtr out_pVolumesDst, AkUInt32 in_uNumChannels)

AK_SpeakerVolumes_Matrix_GetRequiredSize

AKSOUNDENGINE_API AkUInt32 AK_SpeakerVolumes_Matrix_GetRequiredSize(AkUInt32 in_uNumChannelsIn, AkUInt32 in_uNumChannelsOut)

AK_SpeakerVolumes_Vector_Max

AKSOUNDENGINE_API void AK_SpeakerVolumes_Vector_Max(AkSpeakerVolumesVectorPtr io_pVolumesDst, AkSpeakerVolumesConstVectorPtr in_pVolumesSrc, AkUInt32 in_uNumChannels)

AK::SpeakerVolumes::Matrix::GetChannel

AkForceInline VectorPtr GetChannel(MatrixPtr in_pVolumeMx, AkUInt32 in_uIdxChannelIn, AkUInt32 in_uNumChannelsOut)

Definition: AkSpeakerVolumes.h:313

AK_SpeakerVolumes_Vector_MulScalar

AKSOUNDENGINE_API void AK_SpeakerVolumes_Vector_MulScalar(AkSpeakerVolumesVectorPtr io_pVolumesDst, AkReal32 in_fVol, AkUInt32 in_uNumChannels)

AK::SpeakerVolumes::MatrixPtr

AkSpeakerVolumesVectorPtr MatrixPtr

Definition: AkTypedefs.h:104

AK_SpeakerVolumes_Matrix_Add

AKSOUNDENGINE_API void AK_SpeakerVolumes_Matrix_Add(AkSpeakerVolumesMatrixPtr io_pVolumesDst, AkSpeakerVolumesConstMatrixPtr in_pVolumesSrc, AkUInt32 in_uNumChannelsIn, AkUInt32 in_uNumChannelsOut)

AK::SpeakerVolumes::Matrix::Add

AkForceInline void Add(MatrixPtr in_pVolumesDst, ConstMatrixPtr in_pVolumesSrc, AkUInt32 in_uNumChannelsIn, AkUInt32 in_uNumChannelsOut)

Definition: AkSpeakerVolumes.h:355

AK::SpeakerVolumes::Vector::Zero

AkForceInline void Zero(VectorPtr in_pVolumes, AkUInt32 in_uNumChannels)

Definition: AkSpeakerVolumes.h:242

AK_SpeakerVolumes_Matrix_GetChannel

AKSOUNDENGINE_API AkSpeakerVolumesVectorPtr AK_SpeakerVolumes_Matrix_GetChannel(AkSpeakerVolumesMatrixPtr in_pVolumeMx, AkUInt32 in_uIdxChannelIn, AkUInt32 in_uNumChannelsOut)

AK::SpeakerVolumes::Matrix::MAdd

AkForceInline void MAdd(MatrixPtr in_pVolumesDst, ConstMatrixPtr in_pVolumesSrc, AkUInt32 in_uNumChannelsIn, AkUInt32 in_uNumChannelsOut, AkReal32 in_fGain)

Definition: AkSpeakerVolumes.h:364

AK_SpeakerVolumes_Matrix_GetNumElements

AKSOUNDENGINE_API AkUInt32 AK_SpeakerVolumes_Matrix_GetNumElements(AkUInt32 in_uNumChannelsIn, AkUInt32 in_uNumChannelsOut)

AK::SpeakerVolumes::Vector::Add

AkForceInline void Add(VectorPtr in_pVolumesDst, ConstVectorPtr in_pVolumesSrc, AkUInt32 in_uNumChannels)

Definition: AkSpeakerVolumes.h:248

AK_SpeakerVolumes_Vector_CopyAndApplyGain

AKSOUNDENGINE_API void AK_SpeakerVolumes_Vector_CopyAndApplyGain(AkSpeakerVolumesVectorPtr out_pVolumesDst, AkSpeakerVolumesConstVectorPtr in_pVolumesSrc, AkUInt32 in_uNumChannels, AkReal32 in_fGain)

AK::SpeakerVolumes::ConstVectorPtr

AkSpeakerVolumesConstVectorPtr ConstVectorPtr

Definition: AkTypedefs.h:105

AK_SpeakerVolumes_Matrix_MAdd

AKSOUNDENGINE_API void AK_SpeakerVolumes_Matrix_MAdd(AkSpeakerVolumesMatrixPtr io_pVolumesDst, AkSpeakerVolumesConstMatrixPtr in_pVolumesSrc, AkUInt32 in_uNumChannelsIn, AkUInt32 in_uNumChannelsOut, AkReal32 in_fGain)

AkSpeakerVolumesVectorPtr

AkReal32 * AkSpeakerVolumesVectorPtr

Constant volume vector. Access each element with the standard bracket [] operator.

Definition: AkTypedefs.h:86

AkTypes.h

AK::SpeakerVolumes::ConstMatrixPtr

AkSpeakerVolumesConstMatrixPtr ConstMatrixPtr

Definition: AkTypedefs.h:106

AK::SpeakerVolumes::Matrix::Mul

AkForceInline void Mul(MatrixPtr in_pVolumesDst, const AkReal32 in_fVol, AkUInt32 in_uNumChannelsIn, AkUInt32 in_uNumChannelsOut)

Definition: AkSpeakerVolumes.h:346

AkUInt32

uint32_t AkUInt32

Unsigned 32-bit integer

Definition: AkNumeralTypes.h:35

AK::SpeakerVolumes::Matrix::Copy

AkForceInline void Copy(MatrixPtr in_pVolumesDst, ConstMatrixPtr in_pVolumesSrc, AkUInt32 in_uNumChannelsIn, AkUInt32 in_uNumChannelsOut)

Definition: AkSpeakerVolumes.h:323

AK_SpeakerVolumes_Vector_Min

AKSOUNDENGINE_API void AK_SpeakerVolumes_Vector_Min(AkSpeakerVolumesVectorPtr io_pVolumesDst, AkSpeakerVolumesConstVectorPtr in_pVolumesSrc, AkUInt32 in_uNumChannels)

AK_SpeakerVolumes_Vector_Mul

AKSOUNDENGINE_API void AK_SpeakerVolumes_Vector_Mul(AkSpeakerVolumesVectorPtr io_pVolumesDst, AkSpeakerVolumesConstVectorPtr in_pVolumesSrc, AkUInt32 in_uNumChannels)

AkSpeakerVolumesConstMatrixPtr

const AkReal32 * AkSpeakerVolumesConstMatrixPtr

Opaque data structure for storing a collection of external sources. Refer to API in AK/SoundEngine/Co...

Definition: AkTypedefs.h:92

AK_SpeakerVolumes_Matrix_Zero

AKSOUNDENGINE_API void AK_SpeakerVolumes_Matrix_Zero(AkSpeakerVolumesMatrixPtr out_pVolumesDst, AkUInt32 in_uNumChannelsIn, AkUInt32 in_uNumChannelsOut)

AK_SpeakerVolumes_Vector_Copy

AKSOUNDENGINE_API void AK_SpeakerVolumes_Vector_Copy(AkSpeakerVolumesVectorPtr out_pVolumesDst, AkSpeakerVolumesConstVectorPtr in_pVolumesSrc, AkUInt32 in_uNumChannels)

AK::SpeakerVolumes::Matrix::Max

AkForceInline void Max(MatrixPtr in_pVolumesDst, ConstMatrixPtr in_pVolumesSrc, AkUInt32 in_uNumChannelsIn, AkUInt32 in_uNumChannelsOut)

Definition: AkSpeakerVolumes.h:382

AkForceInline

#define AkForceInline

Definition: AkTypes.h:63

AK_SpeakerVolumes_Matrix_GetChannel_Const

AKSOUNDENGINE_API AkSpeakerVolumesConstVectorPtr AK_SpeakerVolumes_Matrix_GetChannel_Const(AkSpeakerVolumesConstMatrixPtr in_pVolumeMx, AkUInt32 in_uIdxChannelIn, AkUInt32 in_uNumChannelsOut)

AK_SpeakerVolumes_Matrix_Max

AKSOUNDENGINE_API void AK_SpeakerVolumes_Matrix_Max(AkSpeakerVolumesMatrixPtr io_pVolumesDst, AkSpeakerVolumesConstMatrixPtr in_pVolumesSrc, AkUInt32 in_uNumChannelsIn, AkUInt32 in_uNumChannelsOut)

AK::SpeakerVolumes::VectorPtr

AkSpeakerVolumesMatrixPtr VectorPtr

Definition: AkTypedefs.h:103

AkSpeakerVolumesConstVectorPtr

const AkReal32 * AkSpeakerVolumesConstVectorPtr

Constant volume matrix. Access each input channel vector with AK::SpeakerVolumes::Matrix::GetChannel(...

Definition: AkTypedefs.h:89

AK_SpeakerVolumes_Vector_Add

AKSOUNDENGINE_API void AK_SpeakerVolumes_Vector_Add(AkSpeakerVolumesVectorPtr io_pVolumesDst, AkSpeakerVolumesConstVectorPtr in_pVolumesSrc, AkUInt32 in_uNumChannels)

AK::SpeakerVolumes::Vector::Min

AkForceInline void Min(AkReal32 *in_pVolumesDst, const AkReal32 *in_pVolumesSrc, AkUInt32 in_uNumChannels)

Definition: AkSpeakerVolumes.h:291

AK::SpeakerVolumes::Vector::Mul

AkForceInline void Mul(VectorPtr in_pVolumesDst, const AkReal32 in_fVol, AkUInt32 in_uNumChannels)

Definition: AkSpeakerVolumes.h:267

이 페이지가 도움이 되었나요?

지원이 필요하신가요?

질문이 있으신가요? 문제를 겪고 계신가요? 더 많은 정보가 필요하신가요? 저희에게 문의해주시면 도와드리겠습니다!

지원 페이지를 방문해 주세요

작업하는 프로젝트에 대해 알려주세요. 언제든지 도와드릴 준비가 되어 있습니다.

프로젝트를 등록하세요. 아무런 조건이나 의무 사항 없이 빠른 시작을 도와드리겠습니다.

Wwise를 시작해 보세요

Wwise SDK