Atom 名前空間

名前空間
namespace	AtomModulationUtils
namespace	ChannelMapPrivate
namespace	FAtomExPlayer_NativeCallbacks
namespace	FAtomPlayer_NativeCallbacks
namespace	FMixerSubmix_NativeCallbacks
namespace	FMixerSubmixPrivate
namespace	MixerSubmixIntrinsics
namespace	ModulationInterfacePrivate
namespace	ModulationPrivate
namespace	Trace

クラス
class	FAnalyzerFacade
struct	FAnalyzerParameters
class	FAtomExPlayback
struct	FAtomExPlaybackListener
class	FAtomExPlayer
struct	FAtomExPlayerArgs
class	FAtomExPlayerGroup
struct	FAtomExPlayerKey
class	FAtomExternalExPlayback
class	FAtomPlayer
struct	FAudioBusKey
struct	FAudioBusSend
struct	FChannelMapParams
struct	FChannelPositionInfo
class	FCircularSampleBuffer
struct	FInitAudioBusSend
class	FMixerAudioBus
struct	FMixerPlatformInfo
class	FMixerSource
class	FMixerSourceManager
struct	FMixerSourcePlayer
class	FMixerSourceVoice
struct	FMixerSourceVoiceBuffer
struct	FMixerSourceVoiceInitParams
class	FMixerSubmix
struct	FModulationDestination
struct	FModulationParameter
struct	FModulatorHandle
struct	FPersistentQuartzSubsystemData
struct	FProxyDataInitParams
class	FQuantizedNotify
class	FQuantizedOtherClockStart
class	FQuantizedPlayCommand
class	FQuantizedQueueCommand
class	FQuantizedTickRateChange
class	FQuantizedTransportReset
class	FQuartzClock
class	FQuartzClockManager
class	FQuartzClockProxy
class	FQuartzMetronome
struct	FQuartzQuantizedCommandHandle
struct	FQuartzQuantizedCommandInitInfo
struct	FQuartzQuantizedRequestData
struct	FShuffleUtil
struct	FSourceManagerInitParams
struct	FSubmixMap
struct	FVoicePool
class	IAnalyzerControls
class	IAnalyzerFactory
class	IAnalyzerResult
class	IAnalyzerSettings
class	IAnalyzerWorker
class	IModulatorSettings
class	IProxyData
class	IQuartzQuantizedCommand
class	ISourceListener
class	TMapAnyKey
class	TProxyData

型定義
using	AtomTaskQueueId = uint32
using	FAlignedByteBuffer = TArray<uint8, FAtomBufferAlignedAllocator>
using	FAlignedFloatBuffer = TArray<float, FAtomBufferAlignedAllocator>
using	FAlignedInt32Buffer = TArray<int32, FAtomBufferAlignedAllocator>
using	FAtomBufferAlignedAllocator = TAlignedHeapAllocator<ATOM_BUFFER_ALIGNMENT>
using	FAtomPlaybackId = uint32
typedef TSharedPtr< FAtomExPlayerGroup, ESPMode::ThreadSafe >	FMixerPlayerGroupPtr
typedef TSharedPtr< FMixerSubmix, ESPMode::ThreadSafe >	FMixerSubmixPtr
typedef TWeakPtr< FMixerSubmix, ESPMode::ThreadSafe >	FMixerSubmixWeakPtr
using	FModulationMixFunction = TFunction<void(float& , float )>
using	FModulationNormalizedConversionFunction = TFunction<void(float& )>
using	FModulationUnitConversionFunction = TFunction<void(float& )>
using	FModulatorHandleId = uint32
using	FModulatorId = uint32
using	FModulatorTypeId = uint32
using	FQuartzClockCommandQueuePtr = TSharedPtr<Audio::TQuartzShareableCommandQueue<FQuartzClock>, ESPMode::ThreadSafe>
using	FQuartzClockCommandQueueWeakPtr = TWeakPtr<Audio::TQuartzShareableCommandQueue<FQuartzClock>, ESPMode::ThreadSafe>
using	FSoundHandleID = uint32
using	MetronomeCommandQueuePtr = TSharedPtr<Audio::TQuartzShareableCommandQueue<FQuartzTickableObject>, ESPMode::ThreadSafe>

列挙型
enum class	EAtomExPlaybackInitializationState : uint8 { NotInitialized , Initializing , Initialized }
enum class	EChannelMapMonoUpmixMethod : uint8 { Linear , EqualPower , FullVolume }
enum class	EChannelMapOrder : uint8 { OutputMajorOrder , InputMajorOrder }
enum class	EMixerDataFormat : int32 { Unknown , Int16 , Float32 , Unsupported }
enum	EMixerSourceSubmixSendStage { PostDistanceAttenuation , PostFader }
enum class	EMixerSourceVoiceCodecType : uint32 {   Standard = 0 , HcaMx , Wave , Aiff ,   RawPcm , InputPort , External , Audio3d ,   Opus , UserDefined , Undefined = 0xff }
enum class	EMixerSourceVoiceStreamingType : uint32 { MemoryOnly , StreamOnly , Mixed }
enum class	EMixerSpeaker : int32 {   FrontLeft , FrontRight , FrontCenter , LowFrequency ,   SurroundLeft , SurroundRight , SurroundBackLeft , SurroundBackRight ,   TopFrontLeft , TopFrontRight , TopRearLeft , TopRearRight ,   BottomFrontLeft , BottomFrontRight , BottomRearLeft , BottomRearRight ,   Count , Unknown , DefaultChannel = FrontLeft }
enum class	EResult : uint8 { Success = 0 , Failure = 1 , NotImplemented = 2 }

関数
static FAutoConsoleCommand	AtomDumpBusCmd (TEXT("atom.rack.drawgraph"), TEXT("Draws the Atom rack heirarchy for this world to the debug output"), FConsoleCommandWithWorldArgsAndOutputDeviceDelegate::CreateLambda([](const TArray< FString > &InArgs, UWorld *InWorld, FOutputDevice &OutLog) { if(InWorld) { if(const FAtomRuntime *AtomRuntime=FAtomRuntimeManager::GetAtomRuntimeRawFromWorld(InWorld)) { AtomRuntime->DrawRacks(OutLog, InArgs);} } }))
template<typename UClassToUse, typename std::enable_if_t< std::is_base_of_v< IAtomProxyDataFactory, UClassToUse >, bool > = true>
IAtomProxyDataFactory *	CastToProxyDataFactory (UObject *InObject)
static FORCEINLINE float	ConvertToDecibels (const float InLinear, const float InFloor=UE_SMALL_NUMBER)
static FORCEINLINE float	ConvertToLinear (const float InDecibels)
bool	Create2DChannelMap (const FChannelMapParams &InParams, TArray< float > &OutChannelMap)
FModulatorHandleId	CreateModulatorHandleId ()
bool	CreateVorbis2DChannelMap (int32 InNumOutputChannels, EChannelMapOrder InOrder, TArray< float > &OutVorbisChannelMap)
void	Deinterleave (const FAlignedFloatBuffer &Buffer, float **OutBuffer, int32 NumChannels, int32 NumFrames)
template<typename ToType, typename FromType>
ToType &	DowncastProxyRef (FromType &InRef)
static void	DrawSubmixHeirarchy (UAtomRackBase *InRack, const TSharedPtr< Atom::FMixerSubmix, ESPMode::ThreadSafe > InInstance, const FAtomRuntime *InRuntime, int32 InIdent, FOutputDevice &Ar, const TCHAR *GroupingText)
static void	DrawSubmixInstances (const FMixerSubmix *InRoot, const int32 InIdent, FOutputDevice &InOutput)
static FORCEINLINE float	FastSin (const float X)
static const FName	FQuantizedNotifyName ("Notify Command")
static FAutoConsoleCommandWithWorldArgsAndOutputDevice	GAtomClearSoloAudio (TEXT("atom.Debug.ClearSoloAudio"), TEXT("Clears solo'ed object"), FConsoleCommandWithWorldArgsAndOutputDeviceDelegate::CreateStatic([](const TArray< FString > &, UWorld *World, FOutputDevice &Ar) { if(FAtomRuntime *AtomRuntime=FAtomRuntimeManager::GetAtomRuntimeRawFromWorld(World)) { AtomRuntime->HandleClearSoloCommand(Ar);} }), ECVF_Cheat)
static FAutoConsoleCommandWithWorldAndArgs	GAtomDebugSound (TEXT("atom.Debug.AtomDebugSound"), TEXT("<filter> Rejects new USoundBase requests where the sound name does not contain the provided filter"), FConsoleCommandWithWorldAndArgsDelegate::CreateStatic([](const TArray< FString > &Args, UWorld *World) { if(FAtomRuntime *AtomRuntime=FAtomRuntimeManager::GetAtomRuntimeRawFromWorld(World)) { AtomRuntime->HandleAtomDebugSound(Args);} }), ECVF_Cheat)
static FAutoConsoleCommand	GAtomDisableHPF (TEXT("atom.Debug.DisableHPF"), TEXT("Disables high-pass filter"), FConsoleCommandWithWorldArgsAndOutputDeviceDelegate::CreateStatic([](const TArray< FString > &, UWorld *World, FOutputDevice &Ar) { if(FAtomRuntime *AtomRuntime=FAtomRuntimeManager::GetAtomRuntimeRawFromWorld(World)) { AtomRuntime->HandleDisableHPFCommand(Ar);} }), ECVF_Cheat)
static FAutoConsoleCommand	GAtomDisableLPF (TEXT("atom.Debug.DisableLPF"), TEXT("Disables low-pass filter"), FConsoleCommandWithWorldArgsAndOutputDeviceDelegate::CreateStatic([](const TArray< FString > &, UWorld *World, FOutputDevice &Ar) { if(FAtomRuntime *AtomRuntime=FAtomRuntimeManager::GetAtomRuntimeRawFromWorld(World)) { AtomRuntime->HandleDisableLPFCommand(Ar);} }), ECVF_Cheat)
static FAutoConsoleCommandWithWorldArgsAndOutputDevice	GAtomDumpSoundInfo (TEXT("atom.Debug.DumpSoundInfo"), TEXT("Dumps sound information to log"), FConsoleCommandWithWorldArgsAndOutputDeviceDelegate::CreateStatic([](const TArray< FString > &, UWorld *World, FOutputDevice &Ar) { if(FAtomRuntime *AtomRuntime=FAtomRuntimeManager::GetAtomRuntimeRawFromWorld(World)) { AtomRuntime->HandleDumpSoundInfoCommand(Ar);} }), ECVF_Cheat)
static FAutoConsoleCommandWithWorldArgsAndOutputDevice	GAtomGetDynamicSoundVolume (TEXT("atom.Debug.AtomGetDynamicSoundVolume"), TEXT("Gets volume for given sound type ('Category', 'Cue' or 'Wave') with provided name"), FConsoleCommandWithWorldArgsAndOutputDeviceDelegate::CreateStatic([](const TArray< FString > &Args, UWorld *World, FOutputDevice &Ar) { if(FAtomRuntime *AtomRuntime=FAtomRuntimeManager::GetAtomRuntimeRawFromWorld(World)) { AtomRuntime->HandleGetDynamicSoundVolumeCommand(Args, Ar);} }), ECVF_Cheat)
static FAutoConsoleCommandWithWorldArgsAndOutputDevice	GAtomListAtomComponents (TEXT("atom.Debug.ListAtomComponents"), TEXT("Dumps a detailed list of all AtomComponent objects"), FConsoleCommandWithWorldArgsAndOutputDeviceDelegate::CreateStatic([](const TArray< FString > &, UWorld *World, FOutputDevice &Ar) { if(FAtomRuntime *AtomRuntime=FAtomRuntimeManager::GetAtomRuntimeRawFromWorld(World)) { AtomRuntime->HandleListAtomComponentsCommand(Ar);} }), ECVF_Cheat)
static FAutoConsoleCommandWithWorldArgsAndOutputDevice	GAtomListPlaybacks (TEXT("atom.Debug.ListPlaybacks"), TEXT("List the PlaybackInstances and whether they have a source"), FConsoleCommandWithWorldArgsAndOutputDeviceDelegate::CreateStatic([](const TArray< FString > &, UWorld *World, FOutputDevice &Ar) { if(FAtomRuntime *AtomRuntime=FAtomRuntimeManager::GetAtomRuntimeRawFromWorld(World)) { AtomRuntime->HandleListPlaybacksCommand(Ar);} }), ECVF_Cheat)
static FAutoConsoleCommandWithWorldArgsAndOutputDevice	GAtomListSoundClasses (TEXT("atom.Debug.ListSoundClasses"), TEXT("Lists a summary of loaded sound asset collated by classes"), FConsoleCommandWithWorldArgsAndOutputDeviceDelegate::CreateStatic([](const TArray< FString > &, UWorld *World, FOutputDevice &Ar) { if(FAtomRuntime *AtomRuntime=FAtomRuntimeManager::GetAtomRuntimeRawFromWorld(World)) { AtomRuntime->HandleListSoundClassesCommand(Ar);} }), ECVF_Cheat)
static FAutoConsoleCommandWithWorldArgsAndOutputDevice	GAtomListSoundClassVolumes (TEXT("atom.Debug.ListSoundClassVolumes"), TEXT("Lists all sound class volumes"), FConsoleCommandWithWorldArgsAndOutputDeviceDelegate::CreateStatic([](const TArray< FString > &, UWorld *World, FOutputDevice &Ar) { if(FAtomRuntime *AtomRuntime=FAtomRuntimeManager::GetAtomRuntimeRawFromWorld(World)) { AtomRuntime->HandleListSoundClassVolumesCommand(Ar);} }), ECVF_Cheat)
static FAutoConsoleCommandWithWorldArgsAndOutputDevice	GAtomListSoundDurations (TEXT("atom.Debug.ListSoundDurations"), TEXT("Lists durations of all active sounds"), FConsoleCommandWithWorldArgsAndOutputDeviceDelegate::CreateStatic([](const TArray< FString > &, UWorld *World, FOutputDevice &Ar) { if(FAtomRuntime *AtomRuntime=FAtomRuntimeManager::GetAtomRuntimeRawFromWorld(World)) { AtomRuntime->HandleListSoundDurationsCommand(Ar);} }), ECVF_Cheat)
static FAutoConsoleCommandWithWorldArgsAndOutputDevice	GAtomMemReport (TEXT("atom.Debug.AtomMemReport"), TEXT("Lists info for Atom memory"), FConsoleCommandWithWorldArgsAndOutputDeviceDelegate::CreateStatic([](const TArray< FString > &Args, UWorld *World, FOutputDevice &Ar) { if(FAtomRuntime *AtomRuntime=FAtomRuntimeManager::GetAtomRuntimeRawFromWorld(World)) { AtomRuntime->HandleAtomMemoryInfo(Args, Ar);} }), ECVF_Cheat)
static FAutoConsoleCommandWithWorldAndArgs	GAtomMixDebugSound (TEXT("atom.Debug.AtomMixDebugSound"), TEXT("<filter> With new mixer enabled, rejects new USoundBase requests where the sound name does not contain the provided filter"), FConsoleCommandWithWorldAndArgsDelegate::CreateStatic([](const TArray< FString > &Args, UWorld *World) { if(FAtomRuntime *AtomRuntime=FAtomRuntimeManager::GetAtomRuntimeRawFromWorld(World)) { AtomRuntime->HandleAtomMixDebugSound(Args);} }), ECVF_Cheat)
static FAutoConsoleCommandWithWorldArgsAndOutputDevice	GAtomPlayAllPIEAudio (TEXT("atom.Debug.PlayAllPIEAudio"), TEXT("Toggls whether or not all devices should play their audio"), FConsoleCommandWithWorldArgsAndOutputDeviceDelegate::CreateStatic([](const TArray< FString > &, UWorld *World, FOutputDevice &Ar) { if(FAtomRuntime *AtomRuntime=FAtomRuntimeManager::GetAtomRuntimeRawFromWorld(World)) { AtomRuntime->HandlePlayAllPIEAtomCommand(Ar);} }), ECVF_Cheat)
static FAutoConsoleCommandWithWorld	GAtomResetAllDynamicSoundVolumes (TEXT("atom.Debug.AtomResetAllDynamicSoundVolumes"), TEXT("Resets all dynamic volumes to unity"), FConsoleCommandWithWorldDelegate::CreateStatic([](UWorld *World) { if(FAtomRuntime *AtomRuntime=FAtomRuntimeManager::GetAtomRuntimeRawFromWorld(World)) { AtomRuntime->HandleResetAllDynamicSoundVolumesCommand();} }), ECVF_Cheat)
static FAutoConsoleCommandWithWorldAndArgs	GAtomResetDynamicSoundVolume (TEXT("atom.Debug.AtomResetDynamicSoundVolume"), TEXT("Resets volume for given sound type ('Class', 'Cue' or 'Wave') with provided name to unity"), FConsoleCommandWithWorldAndArgsDelegate::CreateStatic([](const TArray< FString > &Args, UWorld *World) { if(FAtomRuntime *AtomRuntime=FAtomRuntimeManager::GetAtomRuntimeRawFromWorld(World)) { AtomRuntime->HandleResetDynamicSoundVolumeCommand(Args);} }), ECVF_Cheat)
static FAutoConsoleCommand	GAtomResetSoundState (TEXT("atom.Debug.ResetSoundState"), TEXT("Resets volumes to default and removes test filters"), FConsoleCommandWithWorldArgsAndOutputDeviceDelegate::CreateStatic([](const TArray< FString > &, UWorld *World, FOutputDevice &Ar) { if(FAtomRuntime *AtomRuntime=FAtomRuntimeManager::GetAtomRuntimeRawFromWorld(World)) { AtomRuntime->HandleResetSoundStateCommand(Ar);} }), ECVF_Cheat)
static FAutoConsoleCommandWithWorldArgsAndOutputDevice	GAtomSetBaseSoundRack (TEXT("atom.Debug.SetBaseSoundRack"), TEXT("<MixName> Sets the base sound mix"), FConsoleCommandWithWorldArgsAndOutputDeviceDelegate::CreateStatic([](const TArray< FString > &Args, UWorld *World, FOutputDevice &Ar) { if(FAtomRuntime *AtomRuntime=FAtomRuntimeManager::GetAtomRuntimeRawFromWorld(World)) { AtomRuntime->HandleSetBaseSoundRackCommand(Args, Ar);} }), ECVF_Cheat)
static FAutoConsoleCommandWithWorldAndArgs	GAtomSetDynamicSoundVolume (TEXT("atom.Debug.AtomSetDynamicSoundVolume"), TEXT("Name=<name> Type=<type> Vol=<vol> Sets volume for given sound type ('Class', 'Cue' or 'Wave') with provided name"), FConsoleCommandWithWorldAndArgsDelegate::CreateStatic([](const TArray< FString > &Args, UWorld *World) { if(FAtomRuntime *AtomRuntime=FAtomRuntimeManager::GetAtomRuntimeRawFromWorld(World)) { AtomRuntime->HandleSetDynamicSoundCommand(Args);} }), ECVF_Cheat)
static FAutoConsoleCommandWithWorldArgsAndOutputDevice	GAtomShowSoundClassHierarchy (TEXT("atom.Debug.ShowSoundClassHierarchy"), TEXT(""), FConsoleCommandWithWorldArgsAndOutputDeviceDelegate::CreateStatic([](const TArray< FString > &, UWorld *World, FOutputDevice &Ar) { if(FAtomRuntime *AtomRuntime=FAtomRuntimeManager::GetAtomRuntimeRawFromWorld(World)) { AtomRuntime->HandleShowSoundClassHierarchyCommand(Ar);} }), ECVF_Cheat)
static FAutoConsoleCommandWithWorldArgsAndOutputDevice	GAtomSoloAudio (TEXT("atom.Debug.SoloAudio"), TEXT("Solos the audio device associated with the parent world"), FConsoleCommandWithWorldArgsAndOutputDeviceDelegate::CreateStatic([](const TArray< FString > &, UWorld *World, FOutputDevice &Ar) { if(FAtomRuntime *AtomRuntime=FAtomRuntimeManager::GetAtomRuntimeRawFromWorld(World)) { AtomRuntime->HandleSoloCommand(Ar);} }), ECVF_Cheat)
static FAutoConsoleCommandWithWorldAndArgs	GAtomSoloSoundClass (TEXT("atom.Debug.AtomSoloSoundClass"), TEXT("<name> [nonexclusive] Solos sounds using this UAtomSoundClass. If nonexclusive, existing solos will persist"), FConsoleCommandWithWorldAndArgsDelegate::CreateStatic([](const TArray< FString > &Args, UWorld *World) { if(FAtomRuntime *AtomRuntime=FAtomRuntimeManager::GetAtomRuntimeRawFromWorld(World)) { AtomRuntime->HandleAtomSoloSoundClass(Args);} }), ECVF_Cheat)
static FAutoConsoleCommandWithWorldAndArgs	GAtomSoloSoundCue (TEXT("atom.Debug.AtomSoloSoundCue"), TEXT("<name> [nonexclusive] Solos any type of USoundBase. If nonexclusive, existing solos will persist"), FConsoleCommandWithWorldAndArgsDelegate::CreateStatic([](const TArray< FString > &Args, UWorld *World) { if(FAtomRuntime *AtomRuntime=FAtomRuntimeManager::GetAtomRuntimeRawFromWorld(World)) { AtomRuntime->HandleAtomSoloSoundCue(Args);} }), ECVF_Cheat)
static FAutoConsoleCommandWithWorldAndArgs	GAtomSoloSoundWave (TEXT("atom.Debug.AtomSoloSoundWave"), TEXT("<name> [nonexclusive] Solos USoundWave. If nonexclusive, existing solos will persist"), FConsoleCommandWithWorldAndArgsDelegate::CreateStatic([](const TArray< FString > &Args, UWorld *World) { if(FAtomRuntime *AtomRuntime=FAtomRuntimeManager::GetAtomRuntimeRawFromWorld(World)) { AtomRuntime->HandleAtomSoloSoundWave(Args);} }), ECVF_Cheat)
static FAutoConsoleCommandWithWorldArgsAndOutputDevice	GAtomTestHPF (TEXT("atom.Debug.TestHPF"), TEXT("Sets HPF to max for all sources"), FConsoleCommandWithWorldArgsAndOutputDeviceDelegate::CreateStatic([](const TArray< FString > &, UWorld *World, FOutputDevice &Ar) { if(FAtomRuntime *AtomRuntime=FAtomRuntimeManager::GetAtomRuntimeRawFromWorld(World)) { AtomRuntime->HandleTestHPFCommand(Ar);} }), ECVF_Cheat)
static FAutoConsoleCommandWithWorldArgsAndOutputDevice	GAtomTestLPF (TEXT("atom.Debug.TestLPF"), TEXT("Sets LPF to max for all sources"), FConsoleCommandWithWorldArgsAndOutputDeviceDelegate::CreateStatic([](const TArray< FString > &, UWorld *World, FOutputDevice &Ar) { if(FAtomRuntime *AtomRuntime=FAtomRuntimeManager::GetAtomRuntimeRawFromWorld(World)) { AtomRuntime->HandleTestLPFCommand(Ar);} }), ECVF_Cheat)
static FAutoConsoleCommand	GAtomToggleHRTFForAll (TEXT("atom.Debug.ToggleHRTFForAll"), TEXT("Toggles whether or not HRTF spatialization is enabled for all"), FConsoleCommandWithWorldArgsAndOutputDeviceDelegate::CreateStatic([](const TArray< FString > &, UWorld *World, FOutputDevice &Ar) { if(FAtomRuntime *AtomRuntime=FAtomRuntimeManager::GetAtomRuntimeRawFromWorld(World)) { AtomRuntime->HandleEnableHRTFForAllCommand(Ar);} }), ECVF_Cheat)
static FAutoConsoleCommand	GAtomVersionCmd (TEXT("atom.LibraryVersion"), TEXT("Show the ADX Atom library version information."), FConsoleCommandDelegate::CreateStatic([]() { UE_LOG(LogCriWareAtom, Display, TEXT("ADX Atom library version: %s"), *FAtomRuntime::GetAtomLibraryVersionString());}))
IAnalyzerFactory *	GetAnalyzerFactory (FName InFactoryName)
static int32	GetChannelMapCacheID (const int32 NumSourceChannels, const int32 NumOutputChannels, const bool bIsCenterChannelOnly)
FColor	GetColorForRackType (const FName &InRackName)
FColor	GetColorForRackType (const UAtomRackBase *InRack)
int32	GetCommandBufferInitialCapacity ()
const FModulationParameter &	GetDefaultModulationParameter ()
static FORCEINLINE float	GetFrequencyMultiplier (const float InPitchSemitones)
static FORCEINLINE float	GetLinearFrequencyClamped (const float InFrequencyValue, const FVector2D &Domain, const FVector2D &Range)
static FORCEINLINE float	GetLogFrequencyClamped (const float InValue, const FVector2D &Domain, const FVector2D &Range)
const FModulationParameter *	GetModulationParameterPtr (FName InName)
FName	GetNameForRackType (const UAtomRackBase *InRack)
static FORCEINLINE float	GetSemitones (const float InMultiplier)
void	Interleave (const float **Buffer, FAlignedFloatBuffer &OutBuffer, int32 NumChannels, int32 NumFrames)
bool	IsAudioBufferSilent (const float *AudioBuffer, const int32 NumSamples)
const bool	IsConnectionPerformingSoundfieldConversion (const UAtomRackBase *InputRack, const UAtomRackBase *OutputRack)
bool	IsModulationParameterRegistered (FName InName)
void	IterateOverAllModulationSystems (TFunctionRef< void(AtomModulation::FAtomModulationSystem &)> InFunction)
static const FName	PlayCommandName ("Play Command")
static const FName	QueueCommandName ("Queue Command")
void	RegisterModulationParameter (FName InName, FModulationParameter &&InParameter)
static const FName	StartOtherClockName ("Start Other Clock Command")
static const FName	TickRateChangeCommandName ("Tick Rate Change Command")
const TCHAR *	ToString (EMixerSpeaker InSpeaker)
static const FName	TransportResetCommandName ("Transport Reset Command")
void	UnregisterAllModulationParameters ()
bool	UnregisterModulationParameter (FName InName)

変数
static TArray< TArray< float > >	ChannelMapCache
static FCriticalSection	ChannelMapCacheLock
static constexpr uint32	ChannelMapMaxNumChannels = 16
static constexpr uint32	ChannelMapVorbisNumChannels = 6
const FColor	DefaultAisacPatchColor = FColor(255, 51, 102)
const FColor	DefaultAttenuationColor = FColor(77, 120, 239)
const FColor	DefaultAudioBusColor = FColor(97, 97, 85)
const FColor	DefaultBusColor = FColor(97, 97, 85)
const FColor	DefaultConcurrencyColor = FColor(77, 100, 139)
const FColor	DefaultConfigColor = FColor::Red
const FColor	DefaultCueSheetColor = FColor(255, 127, 39)
const FColor	DefaultDspBusSettingColor = FColor(127, 127, 127)
const FColor	DefaultEffectPresetColor = FColor(99, 63, 56)
const FColor	DefaultModulationControlBusColor = FColor(255, 51, 153)
const FColor	DefaultModulationControlBusMixColor = FColor(255, 153, 153)
const FColor	DefaultModulationGeneratorColor = FColor(204, 51, 153)
const FColor	DefaultModulationParameterColor = FColor(255, 102, 153)
const FColor	DefaultModulationPatchColor = FColor(255, 204, 255)
const FColor	DefaultRackColor = FColor(143, 190, 0)
const FColor	DefaultSoundBaseColor = FColor(97, 85, 212)
const FColor	DefaultSoundClassColor = FColor(255, 175, 0)
const FColor	DefaultSoundCueColor = FColor(255, 127, 39)
const FColor	DefaultSoundProxyColor = FColor(141, 139, 85)
const FColor	DefaultSoundSimpleColor = FColor(212, 97, 85)
const FColor	DefaultSoundSourceBusColor = FColor(212, 97, 85)
const FColor	DefaultSoundWaveColor = FColor(97, 85, 212)
const FColor	DefaultWaveBankColor = FColor(97, 85, 212)
static const Atom::FAlignedFloatBuffer	EmptyBuffer
const FColor	EndpointDefaultRackColor = FColor(249, 242, 231)
const FName	EndpointRackName = TEXT("AtomEndpointRack")
static uint32	GAtomSubmixMixerIDs = 0
static const int32	MaxSupportedSpeakers = (int32)EMixerSpeaker::Count
const FName	RackName = TEXT("AtomRack")
const FColor	SoundfieldDefaultRackColor = FColor(0, 168, 198)
const FColor	SoundfieldEndpointDefaultRackColor = FColor(64, 192, 203)
const FName	SoundfieldEndpointRackName = TEXT("SoundfieldEndpointRack")
const FName	SoundfieldRackName = TEXT("SoundfieldRack")
static TArray< TArray< float > >	VorbisChannelMapCache

型定義詳解

AtomTaskQueueId

using Atom::AtomTaskQueueId = uint32

FAlignedByteBuffer

using Atom::FAlignedByteBuffer = TArray<uint8, FAtomBufferAlignedAllocator>

FAlignedFloatBuffer

using Atom::FAlignedFloatBuffer = TArray<float, FAtomBufferAlignedAllocator>

FAlignedInt32Buffer

using Atom::FAlignedInt32Buffer = TArray<int32, FAtomBufferAlignedAllocator>

FAtomBufferAlignedAllocator

using Atom::FAtomBufferAlignedAllocator = TAlignedHeapAllocator<ATOM_BUFFER_ALIGNMENT>

Aligned allocator used for fast operations.

FAtomPlaybackId

using Atom::FAtomPlaybackId = uint32

FMixerPlayerGroupPtr

typedef TSharedPtr<FAtomExPlayerGroup, ESPMode::ThreadSafe> Atom::FMixerPlayerGroupPtr

FMixerSubmixPtr

typedef TSharedPtr<FMixerSubmix, ESPMode::ThreadSafe> Atom::FMixerSubmixPtr

FMixerSubmixWeakPtr

typedef TWeakPtr<FMixerSubmix, ESPMode::ThreadSafe> Atom::FMixerSubmixWeakPtr

FModulationMixFunction

using Atom::FModulationMixFunction = TFunction<void(float& , float )>

FModulationNormalizedConversionFunction

using Atom::FModulationNormalizedConversionFunction = TFunction<void(float& )>

FModulationUnitConversionFunction

using Atom::FModulationUnitConversionFunction = TFunction<void(float& )>

FModulatorHandleId

using Atom::FModulatorHandleId = uint32

FModulatorId

using Atom::FModulatorId = uint32

FModulatorTypeId

using Atom::FModulatorTypeId = uint32

FQuartzClockCommandQueuePtr

using Atom::FQuartzClockCommandQueuePtr = TSharedPtr<Audio::TQuartzShareableCommandQueue<FQuartzClock>, ESPMode::ThreadSafe>

FQuartzClockCommandQueueWeakPtr

using Atom::FQuartzClockCommandQueueWeakPtr = TWeakPtr<Audio::TQuartzShareableCommandQueue<FQuartzClock>, ESPMode::ThreadSafe>

FSoundHandleID

using Atom::FSoundHandleID = uint32

MetronomeCommandQueuePtr

using Atom::MetronomeCommandQueuePtr = TSharedPtr<Audio::TQuartzShareableCommandQueue<FQuartzTickableObject>, ESPMode::ThreadSafe>

列挙型詳解

EAtomExPlaybackInitializationState

enum class Atom::EAtomExPlaybackInitializationState : uint8

strong

State to track initialization stages.

列挙値
NotInitialized
Initializing
Initialized

EChannelMapMonoUpmixMethod

enum class Atom::EChannelMapMonoUpmixMethod : uint8

strong

Denotes the upmix method for mixing a mono input into the front left and front right speakers.

列挙値
Linear
EqualPower
FullVolume

EChannelMapOrder

enum class Atom::EChannelMapOrder : uint8

strong

Denotes the order of gain coefficients for a channel map.

列挙値
OutputMajorOrder
InputMajorOrder

EMixerDataFormat

enum class Atom::EMixerDataFormat : int32

strong

列挙値
Unknown
Int16	Signed Integer 16-bits
Float32	Float 32-bits
Unsupported

EMixerSourceSubmixSendStage

enum Atom::EMixerSourceSubmixSendStage

列挙値
PostDistanceAttenuation
PostFader

EMixerSourceVoiceCodecType

enum class Atom::EMixerSourceVoiceCodecType : uint32

strong

列挙値
Standard
HcaMx
Wave
Aiff
RawPcm
InputPort
External
Audio3d
Opus
UserDefined
Undefined

EMixerSourceVoiceStreamingType

enum class Atom::EMixerSourceVoiceStreamingType : uint32

strong

列挙値
MemoryOnly
StreamOnly
Mixed

EMixerSpeaker

enum class Atom::EMixerSpeaker : int32

strong

列挙値
FrontLeft
FrontRight
FrontCenter
LowFrequency
SurroundLeft
SurroundRight
SurroundBackLeft
SurroundBackRight
TopFrontLeft
TopFrontRight
TopRearLeft
TopRearRight
BottomFrontLeft
BottomFrontRight
BottomRearLeft
BottomRearRight
Count
Unknown
DefaultChannel

EResult

enum class Atom::EResult : uint8

strong

列挙値
Success
Failure
NotImplemented

関数詳解

AtomDumpBusCmd()

FAutoConsoleCommand Atom::AtomDumpBusCmd ( TEXT("atom.rack.drawgraph") , TEXT("Draws the Atom rack heirarchy for this world to the debug output") , FConsoleCommandWithWorldArgsAndOutputDeviceDelegate::CreateLambda([](const TArray< FString > &InArgs, UWorld *InWorld, FOutputDevice &OutLog) { if(InWorld) { if(const FAtomRuntime *AtomRuntime=FAtomRuntimeManager::GetAtomRuntimeRawFromWorld(InWorld)) { AtomRuntime->DrawRacks(OutLog, InArgs);} } })  )

static

CastToProxyDataFactory()

template<typename UClassToUse, typename std::enable_if_t< std::is_base_of_v< IAtomProxyDataFactory, UClassToUse >, bool > = true>

IAtomProxyDataFactory * Atom::CastToProxyDataFactory

(

UObject *

InObject

)

ConvertToDecibels()

FORCEINLINE float Atom::ConvertToDecibels ( const float InLinear, const float InFloor = UE_SMALL_NUMBER )

static

ConvertToLinear()

FORCEINLINE float Atom::ConvertToLinear ( const float InDecibels )

static

Create2DChannelMap()

CRIWARECORE_API bool Atom::Create2DChannelMap	(	const FChannelMapParams &	InParams,
		TArray< float > &	OutChannelMap )

Create a 2D channel map.

引数

InParams	- Configuration of channel map.
OutChannelMap	- Array to append with channel map.

戻り値

true on success, false on failure.

CreateModulatorHandleId()

FModulatorHandleId Atom::CreateModulatorHandleId

(

)

CreateVorbis2DChannelMap()

CRIWARECORE_API bool Atom::CreateVorbis2DChannelMap	(	int32	InNumOutputChannels,
		EChannelMapOrder	InOrder,
		TArray< float > &	OutVorbisChannelMap )

Create a 2D channel map for 5.1 vorbis input audio.

引数

InNumOutputChannels	- Number of channels in the output audio.
InOrder	- Order of gian coefficients in the output channel map.
OutChannelMap	- Array to append with channel map.

戻り値

true on success, false on failure.

Deinterleave()

void Atom::Deinterleave	(	const FAlignedFloatBuffer &	Buffer,
		float **	OutBuffer,
		int32	NumChannels,
		int32	NumFrames )

DowncastProxyRef()

template<typename ToType, typename FromType>

ToType & Atom::DowncastProxyRef

(

FromType &

InRef

)

This helper function is used to downcast abstract objects during callbacks. Since implementing this API requires frequent downcasting of opaque data, and RTTI is not enabled by default in our codebase, This is useful for avoiding programmer error.

DrawSubmixHeirarchy()

void Atom::DrawSubmixHeirarchy ( UAtomRackBase * InRack, const TSharedPtr< Atom::FMixerSubmix, ESPMode::ThreadSafe > InInstance, const FAtomRuntime * InRuntime, int32 InIdent, FOutputDevice & Ar, const TCHAR * GroupingText )

static

DrawSubmixInstances()

void Atom::DrawSubmixInstances ( const FMixerSubmix * InRoot, const int32 InIdent, FOutputDevice & InOutput )

static

FastSin()

FORCEINLINE float Atom::FastSin ( const float X )

static

FQuantizedNotifyName()

const FName Atom::FQuantizedNotifyName ( "Notify Command" )

static

GAtomClearSoloAudio()

FAutoConsoleCommandWithWorldArgsAndOutputDevice Atom::GAtomClearSoloAudio ( TEXT("atom.Debug.ClearSoloAudio") , TEXT("Clears solo'ed object") , FConsoleCommandWithWorldArgsAndOutputDeviceDelegate::CreateStatic([](const TArray< FString > &, UWorld *World, FOutputDevice &Ar) { if(FAtomRuntime *AtomRuntime=FAtomRuntimeManager::GetAtomRuntimeRawFromWorld(World)) { AtomRuntime->HandleClearSoloCommand(Ar);} }) , ECVF_Cheat  )

static

GAtomDebugSound()

FAutoConsoleCommandWithWorldAndArgs Atom::GAtomDebugSound ( TEXT("atom.Debug.AtomDebugSound") , TEXT("<filter> Rejects new USoundBase requests where the sound name does not contain the provided filter") , FConsoleCommandWithWorldAndArgsDelegate::CreateStatic([](const TArray< FString > &Args, UWorld *World) { if(FAtomRuntime *AtomRuntime=FAtomRuntimeManager::GetAtomRuntimeRawFromWorld(World)) { AtomRuntime->HandleAtomDebugSound(Args);} }) , ECVF_Cheat  )

static

GAtomDisableHPF()

FAutoConsoleCommand Atom::GAtomDisableHPF ( TEXT("atom.Debug.DisableHPF") , TEXT("Disables high-pass filter") , FConsoleCommandWithWorldArgsAndOutputDeviceDelegate::CreateStatic([](const TArray< FString > &, UWorld *World, FOutputDevice &Ar) { if(FAtomRuntime *AtomRuntime=FAtomRuntimeManager::GetAtomRuntimeRawFromWorld(World)) { AtomRuntime->HandleDisableHPFCommand(Ar);} }) , ECVF_Cheat  )

static

GAtomDisableLPF()

FAutoConsoleCommand Atom::GAtomDisableLPF ( TEXT("atom.Debug.DisableLPF") , TEXT("Disables low-pass filter") , FConsoleCommandWithWorldArgsAndOutputDeviceDelegate::CreateStatic([](const TArray< FString > &, UWorld *World, FOutputDevice &Ar) { if(FAtomRuntime *AtomRuntime=FAtomRuntimeManager::GetAtomRuntimeRawFromWorld(World)) { AtomRuntime->HandleDisableLPFCommand(Ar);} }) , ECVF_Cheat  )

static

GAtomDumpSoundInfo()

FAutoConsoleCommandWithWorldArgsAndOutputDevice Atom::GAtomDumpSoundInfo ( TEXT("atom.Debug.DumpSoundInfo") , TEXT("Dumps sound information to log") , FConsoleCommandWithWorldArgsAndOutputDeviceDelegate::CreateStatic([](const TArray< FString > &, UWorld *World, FOutputDevice &Ar) { if(FAtomRuntime *AtomRuntime=FAtomRuntimeManager::GetAtomRuntimeRawFromWorld(World)) { AtomRuntime->HandleDumpSoundInfoCommand(Ar);} }) , ECVF_Cheat  )

static

GAtomGetDynamicSoundVolume()

FAutoConsoleCommandWithWorldArgsAndOutputDevice Atom::GAtomGetDynamicSoundVolume ( TEXT("atom.Debug.AtomGetDynamicSoundVolume") , TEXT("Gets volume for given sound type ('Category', 'Cue' or 'Wave') with provided name") , FConsoleCommandWithWorldArgsAndOutputDeviceDelegate::CreateStatic([](const TArray< FString > &Args, UWorld *World, FOutputDevice &Ar) { if(FAtomRuntime *AtomRuntime=FAtomRuntimeManager::GetAtomRuntimeRawFromWorld(World)) { AtomRuntime->HandleGetDynamicSoundVolumeCommand(Args, Ar);} }) , ECVF_Cheat  )

static

GAtomListAtomComponents()

FAutoConsoleCommandWithWorldArgsAndOutputDevice Atom::GAtomListAtomComponents ( TEXT("atom.Debug.ListAtomComponents") , TEXT("Dumps a detailed list of all AtomComponent objects") , FConsoleCommandWithWorldArgsAndOutputDeviceDelegate::CreateStatic([](const TArray< FString > &, UWorld *World, FOutputDevice &Ar) { if(FAtomRuntime *AtomRuntime=FAtomRuntimeManager::GetAtomRuntimeRawFromWorld(World)) { AtomRuntime->HandleListAtomComponentsCommand(Ar);} }) , ECVF_Cheat  )

static

GAtomListPlaybacks()

FAutoConsoleCommandWithWorldArgsAndOutputDevice Atom::GAtomListPlaybacks ( TEXT("atom.Debug.ListPlaybacks") , TEXT("List the PlaybackInstances and whether they have a source") , FConsoleCommandWithWorldArgsAndOutputDeviceDelegate::CreateStatic([](const TArray< FString > &, UWorld *World, FOutputDevice &Ar) { if(FAtomRuntime *AtomRuntime=FAtomRuntimeManager::GetAtomRuntimeRawFromWorld(World)) { AtomRuntime->HandleListPlaybacksCommand(Ar);} }) , ECVF_Cheat  )

static

GAtomListSoundClasses()

FAutoConsoleCommandWithWorldArgsAndOutputDevice Atom::GAtomListSoundClasses ( TEXT("atom.Debug.ListSoundClasses") , TEXT("Lists a summary of loaded sound asset collated by classes") , FConsoleCommandWithWorldArgsAndOutputDeviceDelegate::CreateStatic([](const TArray< FString > &, UWorld *World, FOutputDevice &Ar) { if(FAtomRuntime *AtomRuntime=FAtomRuntimeManager::GetAtomRuntimeRawFromWorld(World)) { AtomRuntime->HandleListSoundClassesCommand(Ar);} }) , ECVF_Cheat  )

static

GAtomListSoundClassVolumes()

FAutoConsoleCommandWithWorldArgsAndOutputDevice Atom::GAtomListSoundClassVolumes ( TEXT("atom.Debug.ListSoundClassVolumes") , TEXT("Lists all sound class volumes") , FConsoleCommandWithWorldArgsAndOutputDeviceDelegate::CreateStatic([](const TArray< FString > &, UWorld *World, FOutputDevice &Ar) { if(FAtomRuntime *AtomRuntime=FAtomRuntimeManager::GetAtomRuntimeRawFromWorld(World)) { AtomRuntime->HandleListSoundClassVolumesCommand(Ar);} }) , ECVF_Cheat  )

static

GAtomListSoundDurations()

FAutoConsoleCommandWithWorldArgsAndOutputDevice Atom::GAtomListSoundDurations ( TEXT("atom.Debug.ListSoundDurations") , TEXT("Lists durations of all active sounds") , FConsoleCommandWithWorldArgsAndOutputDeviceDelegate::CreateStatic([](const TArray< FString > &, UWorld *World, FOutputDevice &Ar) { if(FAtomRuntime *AtomRuntime=FAtomRuntimeManager::GetAtomRuntimeRawFromWorld(World)) { AtomRuntime->HandleListSoundDurationsCommand(Ar);} }) , ECVF_Cheat  )

static

GAtomMemReport()

FAutoConsoleCommandWithWorldArgsAndOutputDevice Atom::GAtomMemReport ( TEXT("atom.Debug.AtomMemReport") , TEXT("Lists info for Atom memory") , FConsoleCommandWithWorldArgsAndOutputDeviceDelegate::CreateStatic([](const TArray< FString > &Args, UWorld *World, FOutputDevice &Ar) { if(FAtomRuntime *AtomRuntime=FAtomRuntimeManager::GetAtomRuntimeRawFromWorld(World)) { AtomRuntime->HandleAtomMemoryInfo(Args, Ar);} }) , ECVF_Cheat  )

static

GAtomMixDebugSound()

FAutoConsoleCommandWithWorldAndArgs Atom::GAtomMixDebugSound ( TEXT("atom.Debug.AtomMixDebugSound") , TEXT("<filter> With new mixer enabled, rejects new USoundBase requests where the sound name does not contain the provided filter") , FConsoleCommandWithWorldAndArgsDelegate::CreateStatic([](const TArray< FString > &Args, UWorld *World) { if(FAtomRuntime *AtomRuntime=FAtomRuntimeManager::GetAtomRuntimeRawFromWorld(World)) { AtomRuntime->HandleAtomMixDebugSound(Args);} }) , ECVF_Cheat  )

static

GAtomPlayAllPIEAudio()

FAutoConsoleCommandWithWorldArgsAndOutputDevice Atom::GAtomPlayAllPIEAudio ( TEXT("atom.Debug.PlayAllPIEAudio") , TEXT("Toggls whether or not all devices should play their audio") , FConsoleCommandWithWorldArgsAndOutputDeviceDelegate::CreateStatic([](const TArray< FString > &, UWorld *World, FOutputDevice &Ar) { if(FAtomRuntime *AtomRuntime=FAtomRuntimeManager::GetAtomRuntimeRawFromWorld(World)) { AtomRuntime->HandlePlayAllPIEAtomCommand(Ar);} }) , ECVF_Cheat  )

static

GAtomResetAllDynamicSoundVolumes()

FAutoConsoleCommandWithWorld Atom::GAtomResetAllDynamicSoundVolumes ( TEXT("atom.Debug.AtomResetAllDynamicSoundVolumes") , TEXT("Resets all dynamic volumes to unity") , FConsoleCommandWithWorldDelegate::CreateStatic([](UWorld *World) { if(FAtomRuntime *AtomRuntime=FAtomRuntimeManager::GetAtomRuntimeRawFromWorld(World)) { AtomRuntime->HandleResetAllDynamicSoundVolumesCommand();} }) , ECVF_Cheat  )

static

GAtomResetDynamicSoundVolume()

FAutoConsoleCommandWithWorldAndArgs Atom::GAtomResetDynamicSoundVolume ( TEXT("atom.Debug.AtomResetDynamicSoundVolume") , TEXT("Resets volume for given sound type ('Class', 'Cue' or 'Wave') with provided name to unity") , FConsoleCommandWithWorldAndArgsDelegate::CreateStatic([](const TArray< FString > &Args, UWorld *World) { if(FAtomRuntime *AtomRuntime=FAtomRuntimeManager::GetAtomRuntimeRawFromWorld(World)) { AtomRuntime->HandleResetDynamicSoundVolumeCommand(Args);} }) , ECVF_Cheat  )

static

GAtomResetSoundState()

FAutoConsoleCommand Atom::GAtomResetSoundState ( TEXT("atom.Debug.ResetSoundState") , TEXT("Resets volumes to default and removes test filters") , FConsoleCommandWithWorldArgsAndOutputDeviceDelegate::CreateStatic([](const TArray< FString > &, UWorld *World, FOutputDevice &Ar) { if(FAtomRuntime *AtomRuntime=FAtomRuntimeManager::GetAtomRuntimeRawFromWorld(World)) { AtomRuntime->HandleResetSoundStateCommand(Ar);} }) , ECVF_Cheat  )

static

GAtomSetBaseSoundRack()

FAutoConsoleCommandWithWorldArgsAndOutputDevice Atom::GAtomSetBaseSoundRack ( TEXT("atom.Debug.SetBaseSoundRack") , TEXT("<MixName> Sets the base sound mix") , FConsoleCommandWithWorldArgsAndOutputDeviceDelegate::CreateStatic([](const TArray< FString > &Args, UWorld *World, FOutputDevice &Ar) { if(FAtomRuntime *AtomRuntime=FAtomRuntimeManager::GetAtomRuntimeRawFromWorld(World)) { AtomRuntime->HandleSetBaseSoundRackCommand(Args, Ar);} }) , ECVF_Cheat  )

static

GAtomSetDynamicSoundVolume()

FAutoConsoleCommandWithWorldAndArgs Atom::GAtomSetDynamicSoundVolume ( TEXT("atom.Debug.AtomSetDynamicSoundVolume") , TEXT("Name=<name> Type=<type> Vol=<vol> Sets volume for given sound type ('Class', 'Cue' or 'Wave') with provided name") , FConsoleCommandWithWorldAndArgsDelegate::CreateStatic([](const TArray< FString > &Args, UWorld *World) { if(FAtomRuntime *AtomRuntime=FAtomRuntimeManager::GetAtomRuntimeRawFromWorld(World)) { AtomRuntime->HandleSetDynamicSoundCommand(Args);} }) , ECVF_Cheat  )

static

GAtomShowSoundClassHierarchy()

FAutoConsoleCommandWithWorldArgsAndOutputDevice Atom::GAtomShowSoundClassHierarchy ( TEXT("atom.Debug.ShowSoundClassHierarchy") , TEXT("") , FConsoleCommandWithWorldArgsAndOutputDeviceDelegate::CreateStatic([](const TArray< FString > &, UWorld *World, FOutputDevice &Ar) { if(FAtomRuntime *AtomRuntime=FAtomRuntimeManager::GetAtomRuntimeRawFromWorld(World)) { AtomRuntime->HandleShowSoundClassHierarchyCommand(Ar);} }) , ECVF_Cheat  )

static

GAtomSoloAudio()

FAutoConsoleCommandWithWorldArgsAndOutputDevice Atom::GAtomSoloAudio ( TEXT("atom.Debug.SoloAudio") , TEXT("Solos the audio device associated with the parent world") , FConsoleCommandWithWorldArgsAndOutputDeviceDelegate::CreateStatic([](const TArray< FString > &, UWorld *World, FOutputDevice &Ar) { if(FAtomRuntime *AtomRuntime=FAtomRuntimeManager::GetAtomRuntimeRawFromWorld(World)) { AtomRuntime->HandleSoloCommand(Ar);} }) , ECVF_Cheat  )

static

GAtomSoloSoundClass()

FAutoConsoleCommandWithWorldAndArgs Atom::GAtomSoloSoundClass ( TEXT("atom.Debug.AtomSoloSoundClass") , TEXT("<name> [nonexclusive] Solos sounds using this UAtomSoundClass. If nonexclusive, existing solos will persist") , FConsoleCommandWithWorldAndArgsDelegate::CreateStatic([](const TArray< FString > &Args, UWorld *World) { if(FAtomRuntime *AtomRuntime=FAtomRuntimeManager::GetAtomRuntimeRawFromWorld(World)) { AtomRuntime->HandleAtomSoloSoundClass(Args);} }) , ECVF_Cheat  )

static

GAtomSoloSoundCue()

FAutoConsoleCommandWithWorldAndArgs Atom::GAtomSoloSoundCue ( TEXT("atom.Debug.AtomSoloSoundCue") , TEXT("<name> [nonexclusive] Solos any type of USoundBase. If nonexclusive, existing solos will persist") , FConsoleCommandWithWorldAndArgsDelegate::CreateStatic([](const TArray< FString > &Args, UWorld *World) { if(FAtomRuntime *AtomRuntime=FAtomRuntimeManager::GetAtomRuntimeRawFromWorld(World)) { AtomRuntime->HandleAtomSoloSoundCue(Args);} }) , ECVF_Cheat  )

static

GAtomSoloSoundWave()

FAutoConsoleCommandWithWorldAndArgs Atom::GAtomSoloSoundWave ( TEXT("atom.Debug.AtomSoloSoundWave") , TEXT("<name> [nonexclusive] Solos USoundWave. If nonexclusive, existing solos will persist") , FConsoleCommandWithWorldAndArgsDelegate::CreateStatic([](const TArray< FString > &Args, UWorld *World) { if(FAtomRuntime *AtomRuntime=FAtomRuntimeManager::GetAtomRuntimeRawFromWorld(World)) { AtomRuntime->HandleAtomSoloSoundWave(Args);} }) , ECVF_Cheat  )

static

GAtomTestHPF()

FAutoConsoleCommandWithWorldArgsAndOutputDevice Atom::GAtomTestHPF ( TEXT("atom.Debug.TestHPF") , TEXT("Sets HPF to max for all sources") , FConsoleCommandWithWorldArgsAndOutputDeviceDelegate::CreateStatic([](const TArray< FString > &, UWorld *World, FOutputDevice &Ar) { if(FAtomRuntime *AtomRuntime=FAtomRuntimeManager::GetAtomRuntimeRawFromWorld(World)) { AtomRuntime->HandleTestHPFCommand(Ar);} }) , ECVF_Cheat  )

static

GAtomTestLPF()

FAutoConsoleCommandWithWorldArgsAndOutputDevice Atom::GAtomTestLPF ( TEXT("atom.Debug.TestLPF") , TEXT("Sets LPF to max for all sources") , FConsoleCommandWithWorldArgsAndOutputDeviceDelegate::CreateStatic([](const TArray< FString > &, UWorld *World, FOutputDevice &Ar) { if(FAtomRuntime *AtomRuntime=FAtomRuntimeManager::GetAtomRuntimeRawFromWorld(World)) { AtomRuntime->HandleTestLPFCommand(Ar);} }) , ECVF_Cheat  )

static

GAtomToggleHRTFForAll()

FAutoConsoleCommand Atom::GAtomToggleHRTFForAll ( TEXT("atom.Debug.ToggleHRTFForAll") , TEXT("Toggles whether or not HRTF spatialization is enabled for all") , FConsoleCommandWithWorldArgsAndOutputDeviceDelegate::CreateStatic([](const TArray< FString > &, UWorld *World, FOutputDevice &Ar) { if(FAtomRuntime *AtomRuntime=FAtomRuntimeManager::GetAtomRuntimeRawFromWorld(World)) { AtomRuntime->HandleEnableHRTFForAllCommand(Ar);} }) , ECVF_Cheat  )

static

GAtomVersionCmd()

FAutoConsoleCommand Atom::GAtomVersionCmd ( TEXT("atom.LibraryVersion") , TEXT("Show the ADX Atom library version information.") , FConsoleCommandDelegate::CreateStatic([]() { UE_LOG(LogCriWareAtom, Display, TEXT("ADX Atom library version: %s"), *FAtomRuntime::GetAtomLibraryVersionString());})  )

static

GetAnalyzerFactory()

IAnalyzerFactory * Atom::GetAnalyzerFactory

(

FName

InFactoryName

)

GetChannelMapCacheID()

int32 Atom::GetChannelMapCacheID ( const int32 NumSourceChannels, const int32 NumOutputChannels, const bool bIsCenterChannelOnly )

static

GetColorForRackType() [1/2]

FColor Atom::GetColorForRackType

(

const FName &

InRackName

)

GetColorForRackType() [2/2]

FColor Atom::GetColorForRackType

(

const UAtomRackBase *

InRack

)

GetCommandBufferInitialCapacity()

int32 Atom::GetCommandBufferInitialCapacity

(

)

GetDefaultModulationParameter()

CRIWARECORE_API const FModulationParameter & Atom::GetDefaultModulationParameter

(

)

GetFrequencyMultiplier()

FORCEINLINE float Atom::GetFrequencyMultiplier ( const float InPitchSemitones )

static

GetLinearFrequencyClamped()

FORCEINLINE float Atom::GetLinearFrequencyClamped ( const float InFrequencyValue, const FVector2D & Domain, const FVector2D & Range )

static

GetLogFrequencyClamped()

FORCEINLINE float Atom::GetLogFrequencyClamped ( const float InValue, const FVector2D & Domain, const FVector2D & Range )

static

GetModulationParameterPtr()

CRIWARECORE_API const FModulationParameter * Atom::GetModulationParameterPtr

(

FName

InName

)

GetNameForRackType()

FName Atom::GetNameForRackType

(

const UAtomRackBase *

InRack

)

GetSemitones()

FORCEINLINE float Atom::GetSemitones ( const float InMultiplier )

static

Interleave()

void Atom::Interleave	(	const float **	Buffer,
		FAlignedFloatBuffer &	OutBuffer,
		int32	NumChannels,
		int32	NumFrames )

IsAudioBufferSilent()

bool Atom::IsAudioBufferSilent	(	const float *	AudioBuffer,
		const int32	NumSamples )

IsConnectionPerformingSoundfieldConversion()

const bool Atom::IsConnectionPerformingSoundfieldConversion	(	const UAtomRackBase *	InputRack,
		const UAtomRackBase *	OutputRack )

IsModulationParameterRegistered()

CRIWARECORE_API bool Atom::IsModulationParameterRegistered

(

FName

InName

)

IterateOverAllModulationSystems()

CRIWARECORE_API void Atom::IterateOverAllModulationSystems

(

TFunctionRef< void(AtomModulation::FAtomModulationSystem &)>

InFunction

)

PlayCommandName()

const FName Atom::PlayCommandName ( "Play Command" )

static

QueueCommandName()

const FName Atom::QueueCommandName ( "Queue Command" )

static

RegisterModulationParameter()

CRIWARECORE_API void Atom::RegisterModulationParameter	(	FName	InName,
		FModulationParameter &&	InParameter )

StartOtherClockName()

const FName Atom::StartOtherClockName ( "Start Other Clock Command" )

static

TickRateChangeCommandName()

const FName Atom::TickRateChangeCommandName ( "Tick Rate Change Command" )

static

ToString()

const TCHAR * Atom::ToString ( EMixerSpeaker InSpeaker )

inline

TransportResetCommandName()

const FName Atom::TransportResetCommandName ( "Transport Reset Command" )

static

UnregisterAllModulationParameters()

CRIWARECORE_API void Atom::UnregisterAllModulationParameters

(

)

UnregisterModulationParameter()

CRIWARECORE_API bool Atom::UnregisterModulationParameter

(

FName

InName

)

変数詳解

ChannelMapCache

TArray<TArray<float> > Atom::ChannelMapCache

static

ChannelMapCacheLock

FCriticalSection Atom::ChannelMapCacheLock

static

ChannelMapMaxNumChannels

uint32 Atom::ChannelMapMaxNumChannels = 16

staticconstexpr

ChannelMapVorbisNumChannels

uint32 Atom::ChannelMapVorbisNumChannels = 6

staticconstexpr

DefaultAisacPatchColor

const FColor Atom::DefaultAisacPatchColor = FColor(255, 51, 102)

DefaultAttenuationColor

const FColor Atom::DefaultAttenuationColor = FColor(77, 120, 239)

DefaultAudioBusColor

const FColor Atom::DefaultAudioBusColor = FColor(97, 97, 85)

DefaultBusColor

const FColor Atom::DefaultBusColor = FColor(97, 97, 85)

DefaultConcurrencyColor

const FColor Atom::DefaultConcurrencyColor = FColor(77, 100, 139)

DefaultConfigColor

const FColor Atom::DefaultConfigColor = FColor::Red

DefaultCueSheetColor

const FColor Atom::DefaultCueSheetColor = FColor(255, 127, 39)

DefaultDspBusSettingColor

const FColor Atom::DefaultDspBusSettingColor = FColor(127, 127, 127)

DefaultEffectPresetColor

const FColor Atom::DefaultEffectPresetColor = FColor(99, 63, 56)

DefaultModulationControlBusColor

const FColor Atom::DefaultModulationControlBusColor = FColor(255, 51, 153)

DefaultModulationControlBusMixColor

const FColor Atom::DefaultModulationControlBusMixColor = FColor(255, 153, 153)

DefaultModulationGeneratorColor

const FColor Atom::DefaultModulationGeneratorColor = FColor(204, 51, 153)

DefaultModulationParameterColor

const FColor Atom::DefaultModulationParameterColor = FColor(255, 102, 153)

DefaultModulationPatchColor

const FColor Atom::DefaultModulationPatchColor = FColor(255, 204, 255)

DefaultRackColor

const FColor Atom::DefaultRackColor = FColor(143, 190, 0)

DefaultSoundBaseColor

const FColor Atom::DefaultSoundBaseColor = FColor(97, 85, 212)

DefaultSoundClassColor

const FColor Atom::DefaultSoundClassColor = FColor(255, 175, 0)

DefaultSoundCueColor

const FColor Atom::DefaultSoundCueColor = FColor(255, 127, 39)

DefaultSoundProxyColor

const FColor Atom::DefaultSoundProxyColor = FColor(141, 139, 85)

DefaultSoundSimpleColor

const FColor Atom::DefaultSoundSimpleColor = FColor(212, 97, 85)

DefaultSoundSourceBusColor

const FColor Atom::DefaultSoundSourceBusColor = FColor(212, 97, 85)

DefaultSoundWaveColor

const FColor Atom::DefaultSoundWaveColor = FColor(97, 85, 212)

DefaultWaveBankColor

const FColor Atom::DefaultWaveBankColor = FColor(97, 85, 212)

EmptyBuffer

const Atom::FAlignedFloatBuffer Atom::EmptyBuffer

static

EndpointDefaultRackColor

const FColor Atom::EndpointDefaultRackColor = FColor(249, 242, 231)

EndpointRackName

const FName Atom::EndpointRackName = TEXT("AtomEndpointRack")

GAtomSubmixMixerIDs

uint32 Atom::GAtomSubmixMixerIDs = 0

static

MaxSupportedSpeakers

const int32 Atom::MaxSupportedSpeakers = (int32)EMixerSpeaker::Count

static

RackName

const FName Atom::RackName = TEXT("AtomRack")

SoundfieldDefaultRackColor

const FColor Atom::SoundfieldDefaultRackColor = FColor(0, 168, 198)

SoundfieldEndpointDefaultRackColor

const FColor Atom::SoundfieldEndpointDefaultRackColor = FColor(64, 192, 203)

SoundfieldEndpointRackName

const FName Atom::SoundfieldEndpointRackName = TEXT("SoundfieldEndpointRack")

SoundfieldRackName

const FName Atom::SoundfieldRackName = TEXT("SoundfieldRack")

VorbisChannelMapCache

TArray<TArray<float> > Atom::VorbisChannelMapCache

static