mirror of
https://github.com/swordbluesword/PalWorld-NetCrack.git
synced 2025-04-29 02:47:17 +09:00
3396 lines
132 KiB
C++
3396 lines
132 KiB
C++
#pragma once
|
|
|
|
// Dumped with Dumper-7!
|
|
|
|
|
|
#include "../SDK.hpp"
|
|
|
|
namespace SDK
|
|
{
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
// FUNCTIONS
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
|
|
|
|
// Class AudioMixer.SynthComponent
|
|
// (SceneComponent)
|
|
|
|
class UClass* USynthComponent::StaticClass()
|
|
{
|
|
static class UClass* Clss = nullptr;
|
|
|
|
if (!Clss)
|
|
Clss = UObject::FindClassFast("SynthComponent");
|
|
|
|
return Clss;
|
|
}
|
|
|
|
|
|
// SynthComponent AudioMixer.Default__SynthComponent
|
|
// (Public, ClassDefaultObject, ArchetypeObject)
|
|
|
|
class USynthComponent* USynthComponent::GetDefaultObj()
|
|
{
|
|
static class USynthComponent* Default = nullptr;
|
|
|
|
if (!Default)
|
|
Default = static_cast<USynthComponent*>(USynthComponent::StaticClass()->DefaultObject);
|
|
|
|
return Default;
|
|
}
|
|
|
|
|
|
// Function AudioMixer.SynthComponent.Stop
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
|
|
void USynthComponent::Stop()
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("SynthComponent", "Stop");
|
|
|
|
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, nullptr);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
}
|
|
|
|
|
|
// Function AudioMixer.SynthComponent.Start
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
|
|
void USynthComponent::Start()
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("SynthComponent", "Start");
|
|
|
|
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, nullptr);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
}
|
|
|
|
|
|
// Function AudioMixer.SynthComponent.SetVolumeMultiplier
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float VolumeMultiplier (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void USynthComponent::SetVolumeMultiplier(float VolumeMultiplier)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("SynthComponent", "SetVolumeMultiplier");
|
|
|
|
Params::USynthComponent_SetVolumeMultiplier_Params Parms{};
|
|
|
|
Parms.VolumeMultiplier = VolumeMultiplier;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
}
|
|
|
|
|
|
// Function AudioMixer.SynthComponent.SetSubmixSend
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class USoundSubmixBase* Submix (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float SendLevel (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void USynthComponent::SetSubmixSend(class USoundSubmixBase* Submix, float SendLevel)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("SynthComponent", "SetSubmixSend");
|
|
|
|
Params::USynthComponent_SetSubmixSend_Params Parms{};
|
|
|
|
Parms.Submix = Submix;
|
|
Parms.SendLevel = SendLevel;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
}
|
|
|
|
|
|
// Function AudioMixer.SynthComponent.SetOutputToBusOnly
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bInOutputToBusOnly (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void USynthComponent::SetOutputToBusOnly(bool bInOutputToBusOnly)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("SynthComponent", "SetOutputToBusOnly");
|
|
|
|
Params::USynthComponent_SetOutputToBusOnly_Params Parms{};
|
|
|
|
Parms.bInOutputToBusOnly = bInOutputToBusOnly;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
}
|
|
|
|
|
|
// Function AudioMixer.SynthComponent.SetLowPassFilterFrequency
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float InLowPassFilterFrequency (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void USynthComponent::SetLowPassFilterFrequency(float InLowPassFilterFrequency)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("SynthComponent", "SetLowPassFilterFrequency");
|
|
|
|
Params::USynthComponent_SetLowPassFilterFrequency_Params Parms{};
|
|
|
|
Parms.InLowPassFilterFrequency = InLowPassFilterFrequency;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
}
|
|
|
|
|
|
// Function AudioMixer.SynthComponent.SetLowPassFilterEnabled
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool InLowPassFilterEnabled (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void USynthComponent::SetLowPassFilterEnabled(bool InLowPassFilterEnabled)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("SynthComponent", "SetLowPassFilterEnabled");
|
|
|
|
Params::USynthComponent_SetLowPassFilterEnabled_Params Parms{};
|
|
|
|
Parms.InLowPassFilterEnabled = InLowPassFilterEnabled;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
}
|
|
|
|
|
|
// Function AudioMixer.SynthComponent.IsPlaying
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
bool USynthComponent::IsPlaying()
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("SynthComponent", "IsPlaying");
|
|
|
|
Params::USynthComponent_IsPlaying_Params Parms{};
|
|
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function AudioMixer.SynthComponent.FadeOut
|
|
// (Final, Native, Public, BlueprintCallable, Const)
|
|
// Parameters:
|
|
// float FadeOutDuration (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float FadeVolumeLevel (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// enum class EAudioFaderCurve FadeCurve (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void USynthComponent::FadeOut(float FadeOutDuration, float FadeVolumeLevel, enum class EAudioFaderCurve FadeCurve)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("SynthComponent", "FadeOut");
|
|
|
|
Params::USynthComponent_FadeOut_Params Parms{};
|
|
|
|
Parms.FadeOutDuration = FadeOutDuration;
|
|
Parms.FadeVolumeLevel = FadeVolumeLevel;
|
|
Parms.FadeCurve = FadeCurve;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
}
|
|
|
|
|
|
// Function AudioMixer.SynthComponent.FadeIn
|
|
// (Final, Native, Public, BlueprintCallable, Const)
|
|
// Parameters:
|
|
// float FadeInDuration (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float FadeVolumeLevel (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float StartTime (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// enum class EAudioFaderCurve FadeCurve (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void USynthComponent::FadeIn(float FadeInDuration, float FadeVolumeLevel, float StartTime, enum class EAudioFaderCurve FadeCurve)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("SynthComponent", "FadeIn");
|
|
|
|
Params::USynthComponent_FadeIn_Params Parms{};
|
|
|
|
Parms.FadeInDuration = FadeInDuration;
|
|
Parms.FadeVolumeLevel = FadeVolumeLevel;
|
|
Parms.StartTime = StartTime;
|
|
Parms.FadeCurve = FadeCurve;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
}
|
|
|
|
|
|
// Function AudioMixer.SynthComponent.AdjustVolume
|
|
// (Final, Native, Public, BlueprintCallable, Const)
|
|
// Parameters:
|
|
// float AdjustVolumeDuration (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float AdjustVolumeLevel (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// enum class EAudioFaderCurve FadeCurve (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void USynthComponent::AdjustVolume(float AdjustVolumeDuration, float AdjustVolumeLevel, enum class EAudioFaderCurve FadeCurve)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("SynthComponent", "AdjustVolume");
|
|
|
|
Params::USynthComponent_AdjustVolume_Params Parms{};
|
|
|
|
Parms.AdjustVolumeDuration = AdjustVolumeDuration;
|
|
Parms.AdjustVolumeLevel = AdjustVolumeLevel;
|
|
Parms.FadeCurve = FadeCurve;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
}
|
|
|
|
|
|
// Class AudioMixer.AudioGenerator
|
|
// (None)
|
|
|
|
class UClass* UAudioGenerator::StaticClass()
|
|
{
|
|
static class UClass* Clss = nullptr;
|
|
|
|
if (!Clss)
|
|
Clss = UObject::FindClassFast("AudioGenerator");
|
|
|
|
return Clss;
|
|
}
|
|
|
|
|
|
// AudioGenerator AudioMixer.Default__AudioGenerator
|
|
// (Public, ClassDefaultObject, ArchetypeObject)
|
|
|
|
class UAudioGenerator* UAudioGenerator::GetDefaultObj()
|
|
{
|
|
static class UAudioGenerator* Default = nullptr;
|
|
|
|
if (!Default)
|
|
Default = static_cast<UAudioGenerator*>(UAudioGenerator::StaticClass()->DefaultObject);
|
|
|
|
return Default;
|
|
}
|
|
|
|
|
|
// Class AudioMixer.AudioDeviceNotificationSubsystem
|
|
// (None)
|
|
|
|
class UClass* UAudioDeviceNotificationSubsystem::StaticClass()
|
|
{
|
|
static class UClass* Clss = nullptr;
|
|
|
|
if (!Clss)
|
|
Clss = UObject::FindClassFast("AudioDeviceNotificationSubsystem");
|
|
|
|
return Clss;
|
|
}
|
|
|
|
|
|
// AudioDeviceNotificationSubsystem AudioMixer.Default__AudioDeviceNotificationSubsystem
|
|
// (Public, ClassDefaultObject, ArchetypeObject)
|
|
|
|
class UAudioDeviceNotificationSubsystem* UAudioDeviceNotificationSubsystem::GetDefaultObj()
|
|
{
|
|
static class UAudioDeviceNotificationSubsystem* Default = nullptr;
|
|
|
|
if (!Default)
|
|
Default = static_cast<UAudioDeviceNotificationSubsystem*>(UAudioDeviceNotificationSubsystem::StaticClass()->DefaultObject);
|
|
|
|
return Default;
|
|
}
|
|
|
|
|
|
// Class AudioMixer.AudioMixerBlueprintLibrary
|
|
// (None)
|
|
|
|
class UClass* UAudioMixerBlueprintLibrary::StaticClass()
|
|
{
|
|
static class UClass* Clss = nullptr;
|
|
|
|
if (!Clss)
|
|
Clss = UObject::FindClassFast("AudioMixerBlueprintLibrary");
|
|
|
|
return Clss;
|
|
}
|
|
|
|
|
|
// AudioMixerBlueprintLibrary AudioMixer.Default__AudioMixerBlueprintLibrary
|
|
// (Public, ClassDefaultObject, ArchetypeObject)
|
|
|
|
class UAudioMixerBlueprintLibrary* UAudioMixerBlueprintLibrary::GetDefaultObj()
|
|
{
|
|
static class UAudioMixerBlueprintLibrary* Default = nullptr;
|
|
|
|
if (!Default)
|
|
Default = static_cast<UAudioMixerBlueprintLibrary*>(UAudioMixerBlueprintLibrary::StaticClass()->DefaultObject);
|
|
|
|
return Default;
|
|
}
|
|
|
|
|
|
// Function AudioMixer.AudioMixerBlueprintLibrary.TrimAudioCache
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float InMegabytesToFree (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
float UAudioMixerBlueprintLibrary::TrimAudioCache(float InMegabytesToFree)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("AudioMixerBlueprintLibrary", "TrimAudioCache");
|
|
|
|
Params::UAudioMixerBlueprintLibrary_TrimAudioCache_Params Parms{};
|
|
|
|
Parms.InMegabytesToFree = InMegabytesToFree;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function AudioMixer.AudioMixerBlueprintLibrary.SwapAudioOutputDevice
|
|
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class FString NewDeviceId (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// FDelegateProperty_ OnCompletedDeviceSwap (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UAudioMixerBlueprintLibrary::SwapAudioOutputDevice(class UObject* WorldContextObject, const class FString& NewDeviceId, FDelegateProperty_& OnCompletedDeviceSwap)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("AudioMixerBlueprintLibrary", "SwapAudioOutputDevice");
|
|
|
|
Params::UAudioMixerBlueprintLibrary_SwapAudioOutputDevice_Params Parms{};
|
|
|
|
Parms.WorldContextObject = WorldContextObject;
|
|
Parms.NewDeviceId = NewDeviceId;
|
|
Parms.OnCompletedDeviceSwap = OnCompletedDeviceSwap;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
}
|
|
|
|
|
|
// Function AudioMixer.AudioMixerBlueprintLibrary.StopRecordingOutput
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// enum class EAudioRecordingExportTypeExportType (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class FString Name (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class FString Path (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class USoundSubmix* SubmixToRecord (Parm, ZeroConstructor, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class USoundWave* ExistingSoundWaveToOverwrite (Parm, ZeroConstructor, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class USoundWave* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
class USoundWave* UAudioMixerBlueprintLibrary::StopRecordingOutput(class UObject* WorldContextObject, enum class EAudioRecordingExportType ExportType, const class FString& Name, const class FString& Path, class USoundSubmix* SubmixToRecord, class USoundWave* ExistingSoundWaveToOverwrite)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("AudioMixerBlueprintLibrary", "StopRecordingOutput");
|
|
|
|
Params::UAudioMixerBlueprintLibrary_StopRecordingOutput_Params Parms{};
|
|
|
|
Parms.WorldContextObject = WorldContextObject;
|
|
Parms.ExportType = ExportType;
|
|
Parms.Name = Name;
|
|
Parms.Path = Path;
|
|
Parms.SubmixToRecord = SubmixToRecord;
|
|
Parms.ExistingSoundWaveToOverwrite = ExistingSoundWaveToOverwrite;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function AudioMixer.AudioMixerBlueprintLibrary.StopAudioBus
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class UAudioBus* AudioBus (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UAudioMixerBlueprintLibrary::StopAudioBus(class UObject* WorldContextObject, class UAudioBus* AudioBus)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("AudioMixerBlueprintLibrary", "StopAudioBus");
|
|
|
|
Params::UAudioMixerBlueprintLibrary_StopAudioBus_Params Parms{};
|
|
|
|
Parms.WorldContextObject = WorldContextObject;
|
|
Parms.AudioBus = AudioBus;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
}
|
|
|
|
|
|
// Function AudioMixer.AudioMixerBlueprintLibrary.StopAnalyzingOutput
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class USoundSubmix* SubmixToStopAnalyzing (Parm, ZeroConstructor, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UAudioMixerBlueprintLibrary::StopAnalyzingOutput(class UObject* WorldContextObject, class USoundSubmix* SubmixToStopAnalyzing)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("AudioMixerBlueprintLibrary", "StopAnalyzingOutput");
|
|
|
|
Params::UAudioMixerBlueprintLibrary_StopAnalyzingOutput_Params Parms{};
|
|
|
|
Parms.WorldContextObject = WorldContextObject;
|
|
Parms.SubmixToStopAnalyzing = SubmixToStopAnalyzing;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
}
|
|
|
|
|
|
// Function AudioMixer.AudioMixerBlueprintLibrary.StartRecordingOutput
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float ExpectedDuration (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class USoundSubmix* SubmixToRecord (Parm, ZeroConstructor, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UAudioMixerBlueprintLibrary::StartRecordingOutput(class UObject* WorldContextObject, float ExpectedDuration, class USoundSubmix* SubmixToRecord)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("AudioMixerBlueprintLibrary", "StartRecordingOutput");
|
|
|
|
Params::UAudioMixerBlueprintLibrary_StartRecordingOutput_Params Parms{};
|
|
|
|
Parms.WorldContextObject = WorldContextObject;
|
|
Parms.ExpectedDuration = ExpectedDuration;
|
|
Parms.SubmixToRecord = SubmixToRecord;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
}
|
|
|
|
|
|
// Function AudioMixer.AudioMixerBlueprintLibrary.StartAudioBus
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class UAudioBus* AudioBus (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UAudioMixerBlueprintLibrary::StartAudioBus(class UObject* WorldContextObject, class UAudioBus* AudioBus)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("AudioMixerBlueprintLibrary", "StartAudioBus");
|
|
|
|
Params::UAudioMixerBlueprintLibrary_StartAudioBus_Params Parms{};
|
|
|
|
Parms.WorldContextObject = WorldContextObject;
|
|
Parms.AudioBus = AudioBus;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
}
|
|
|
|
|
|
// Function AudioMixer.AudioMixerBlueprintLibrary.StartAnalyzingOutput
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class USoundSubmix* SubmixToAnalyze (Parm, ZeroConstructor, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// enum class EFFTSize FFTSize (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// enum class EFFTPeakInterpolationMethodInterpolationMethod (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// enum class EFFTWindowType WindowType (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float HopSize (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// enum class EAudioSpectrumType SpectrumType (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UAudioMixerBlueprintLibrary::StartAnalyzingOutput(class UObject* WorldContextObject, class USoundSubmix* SubmixToAnalyze, enum class EFFTSize FFTSize, enum class EFFTPeakInterpolationMethod InterpolationMethod, enum class EFFTWindowType WindowType, float HopSize, enum class EAudioSpectrumType SpectrumType)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("AudioMixerBlueprintLibrary", "StartAnalyzingOutput");
|
|
|
|
Params::UAudioMixerBlueprintLibrary_StartAnalyzingOutput_Params Parms{};
|
|
|
|
Parms.WorldContextObject = WorldContextObject;
|
|
Parms.SubmixToAnalyze = SubmixToAnalyze;
|
|
Parms.FFTSize = FFTSize;
|
|
Parms.InterpolationMethod = InterpolationMethod;
|
|
Parms.WindowType = WindowType;
|
|
Parms.HopSize = HopSize;
|
|
Parms.SpectrumType = SpectrumType;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
}
|
|
|
|
|
|
// Function AudioMixer.AudioMixerBlueprintLibrary.SetSubmixEffectChainOverride
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class USoundSubmix* SoundSubmix (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// TArray<class USoundEffectSubmixPreset*>SubmixEffectPresetChain (Parm, ZeroConstructor, NativeAccessSpecifierPublic)
|
|
// float FadeTimeSec (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UAudioMixerBlueprintLibrary::SetSubmixEffectChainOverride(class UObject* WorldContextObject, class USoundSubmix* SoundSubmix, const TArray<class USoundEffectSubmixPreset*>& SubmixEffectPresetChain, float FadeTimeSec)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("AudioMixerBlueprintLibrary", "SetSubmixEffectChainOverride");
|
|
|
|
Params::UAudioMixerBlueprintLibrary_SetSubmixEffectChainOverride_Params Parms{};
|
|
|
|
Parms.WorldContextObject = WorldContextObject;
|
|
Parms.SoundSubmix = SoundSubmix;
|
|
Parms.SubmixEffectPresetChain = SubmixEffectPresetChain;
|
|
Parms.FadeTimeSec = FadeTimeSec;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
}
|
|
|
|
|
|
// Function AudioMixer.AudioMixerBlueprintLibrary.SetBypassSourceEffectChainEntry
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class USoundEffectSourcePresetChain*PresetChain (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// int32 EntryIndex (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// bool bBypassed (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UAudioMixerBlueprintLibrary::SetBypassSourceEffectChainEntry(class UObject* WorldContextObject, class USoundEffectSourcePresetChain* PresetChain, int32 EntryIndex, bool bBypassed)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("AudioMixerBlueprintLibrary", "SetBypassSourceEffectChainEntry");
|
|
|
|
Params::UAudioMixerBlueprintLibrary_SetBypassSourceEffectChainEntry_Params Parms{};
|
|
|
|
Parms.WorldContextObject = WorldContextObject;
|
|
Parms.PresetChain = PresetChain;
|
|
Parms.EntryIndex = EntryIndex;
|
|
Parms.bBypassed = bBypassed;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
}
|
|
|
|
|
|
// Function AudioMixer.AudioMixerBlueprintLibrary.ResumeRecordingOutput
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class USoundSubmix* SubmixToPause (Parm, ZeroConstructor, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UAudioMixerBlueprintLibrary::ResumeRecordingOutput(class UObject* WorldContextObject, class USoundSubmix* SubmixToPause)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("AudioMixerBlueprintLibrary", "ResumeRecordingOutput");
|
|
|
|
Params::UAudioMixerBlueprintLibrary_ResumeRecordingOutput_Params Parms{};
|
|
|
|
Parms.WorldContextObject = WorldContextObject;
|
|
Parms.SubmixToPause = SubmixToPause;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
}
|
|
|
|
|
|
// Function AudioMixer.AudioMixerBlueprintLibrary.ReplaceSubmixEffect
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class USoundSubmix* InSoundSubmix (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// int32 SubmixChainIndex (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class USoundEffectSubmixPreset* SubmixEffectPreset (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UAudioMixerBlueprintLibrary::ReplaceSubmixEffect(class UObject* WorldContextObject, class USoundSubmix* InSoundSubmix, int32 SubmixChainIndex, class USoundEffectSubmixPreset* SubmixEffectPreset)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("AudioMixerBlueprintLibrary", "ReplaceSubmixEffect");
|
|
|
|
Params::UAudioMixerBlueprintLibrary_ReplaceSubmixEffect_Params Parms{};
|
|
|
|
Parms.WorldContextObject = WorldContextObject;
|
|
Parms.InSoundSubmix = InSoundSubmix;
|
|
Parms.SubmixChainIndex = SubmixChainIndex;
|
|
Parms.SubmixEffectPreset = SubmixEffectPreset;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
}
|
|
|
|
|
|
// Function AudioMixer.AudioMixerBlueprintLibrary.ReplaceSoundEffectSubmix
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class USoundSubmix* InSoundSubmix (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// int32 SubmixChainIndex (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class USoundEffectSubmixPreset* SubmixEffectPreset (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UAudioMixerBlueprintLibrary::ReplaceSoundEffectSubmix(class UObject* WorldContextObject, class USoundSubmix* InSoundSubmix, int32 SubmixChainIndex, class USoundEffectSubmixPreset* SubmixEffectPreset)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("AudioMixerBlueprintLibrary", "ReplaceSoundEffectSubmix");
|
|
|
|
Params::UAudioMixerBlueprintLibrary_ReplaceSoundEffectSubmix_Params Parms{};
|
|
|
|
Parms.WorldContextObject = WorldContextObject;
|
|
Parms.InSoundSubmix = InSoundSubmix;
|
|
Parms.SubmixChainIndex = SubmixChainIndex;
|
|
Parms.SubmixEffectPreset = SubmixEffectPreset;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
}
|
|
|
|
|
|
// Function AudioMixer.AudioMixerBlueprintLibrary.RemoveSubmixEffectPresetAtIndex
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class USoundSubmix* SoundSubmix (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// int32 SubmixChainIndex (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UAudioMixerBlueprintLibrary::RemoveSubmixEffectPresetAtIndex(class UObject* WorldContextObject, class USoundSubmix* SoundSubmix, int32 SubmixChainIndex)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("AudioMixerBlueprintLibrary", "RemoveSubmixEffectPresetAtIndex");
|
|
|
|
Params::UAudioMixerBlueprintLibrary_RemoveSubmixEffectPresetAtIndex_Params Parms{};
|
|
|
|
Parms.WorldContextObject = WorldContextObject;
|
|
Parms.SoundSubmix = SoundSubmix;
|
|
Parms.SubmixChainIndex = SubmixChainIndex;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
}
|
|
|
|
|
|
// Function AudioMixer.AudioMixerBlueprintLibrary.RemoveSubmixEffectPreset
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class USoundSubmix* SoundSubmix (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class USoundEffectSubmixPreset* SubmixEffectPreset (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UAudioMixerBlueprintLibrary::RemoveSubmixEffectPreset(class UObject* WorldContextObject, class USoundSubmix* SoundSubmix, class USoundEffectSubmixPreset* SubmixEffectPreset)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("AudioMixerBlueprintLibrary", "RemoveSubmixEffectPreset");
|
|
|
|
Params::UAudioMixerBlueprintLibrary_RemoveSubmixEffectPreset_Params Parms{};
|
|
|
|
Parms.WorldContextObject = WorldContextObject;
|
|
Parms.SoundSubmix = SoundSubmix;
|
|
Parms.SubmixEffectPreset = SubmixEffectPreset;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
}
|
|
|
|
|
|
// Function AudioMixer.AudioMixerBlueprintLibrary.RemoveSubmixEffectAtIndex
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class USoundSubmix* SoundSubmix (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// int32 SubmixChainIndex (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UAudioMixerBlueprintLibrary::RemoveSubmixEffectAtIndex(class UObject* WorldContextObject, class USoundSubmix* SoundSubmix, int32 SubmixChainIndex)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("AudioMixerBlueprintLibrary", "RemoveSubmixEffectAtIndex");
|
|
|
|
Params::UAudioMixerBlueprintLibrary_RemoveSubmixEffectAtIndex_Params Parms{};
|
|
|
|
Parms.WorldContextObject = WorldContextObject;
|
|
Parms.SoundSubmix = SoundSubmix;
|
|
Parms.SubmixChainIndex = SubmixChainIndex;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
}
|
|
|
|
|
|
// Function AudioMixer.AudioMixerBlueprintLibrary.RemoveSubmixEffect
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class USoundSubmix* SoundSubmix (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class USoundEffectSubmixPreset* SubmixEffectPreset (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UAudioMixerBlueprintLibrary::RemoveSubmixEffect(class UObject* WorldContextObject, class USoundSubmix* SoundSubmix, class USoundEffectSubmixPreset* SubmixEffectPreset)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("AudioMixerBlueprintLibrary", "RemoveSubmixEffect");
|
|
|
|
Params::UAudioMixerBlueprintLibrary_RemoveSubmixEffect_Params Parms{};
|
|
|
|
Parms.WorldContextObject = WorldContextObject;
|
|
Parms.SoundSubmix = SoundSubmix;
|
|
Parms.SubmixEffectPreset = SubmixEffectPreset;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
}
|
|
|
|
|
|
// Function AudioMixer.AudioMixerBlueprintLibrary.RemoveSourceEffectFromPresetChain
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class USoundEffectSourcePresetChain*PresetChain (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// int32 EntryIndex (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UAudioMixerBlueprintLibrary::RemoveSourceEffectFromPresetChain(class UObject* WorldContextObject, class USoundEffectSourcePresetChain* PresetChain, int32 EntryIndex)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("AudioMixerBlueprintLibrary", "RemoveSourceEffectFromPresetChain");
|
|
|
|
Params::UAudioMixerBlueprintLibrary_RemoveSourceEffectFromPresetChain_Params Parms{};
|
|
|
|
Parms.WorldContextObject = WorldContextObject;
|
|
Parms.PresetChain = PresetChain;
|
|
Parms.EntryIndex = EntryIndex;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
}
|
|
|
|
|
|
// Function AudioMixer.AudioMixerBlueprintLibrary.RemoveMasterSubmixEffect
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class USoundEffectSubmixPreset* SubmixEffectPreset (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UAudioMixerBlueprintLibrary::RemoveMasterSubmixEffect(class UObject* WorldContextObject, class USoundEffectSubmixPreset* SubmixEffectPreset)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("AudioMixerBlueprintLibrary", "RemoveMasterSubmixEffect");
|
|
|
|
Params::UAudioMixerBlueprintLibrary_RemoveMasterSubmixEffect_Params Parms{};
|
|
|
|
Parms.WorldContextObject = WorldContextObject;
|
|
Parms.SubmixEffectPreset = SubmixEffectPreset;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
}
|
|
|
|
|
|
// Function AudioMixer.AudioMixerBlueprintLibrary.PrimeSoundForPlayback
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class USoundWave* SoundWave (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// FDelegateProperty_ OnLoadCompletion (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UAudioMixerBlueprintLibrary::PrimeSoundForPlayback(class USoundWave* SoundWave, FDelegateProperty_ OnLoadCompletion)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("AudioMixerBlueprintLibrary", "PrimeSoundForPlayback");
|
|
|
|
Params::UAudioMixerBlueprintLibrary_PrimeSoundForPlayback_Params Parms{};
|
|
|
|
Parms.SoundWave = SoundWave;
|
|
Parms.OnLoadCompletion = OnLoadCompletion;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
}
|
|
|
|
|
|
// Function AudioMixer.AudioMixerBlueprintLibrary.PrimeSoundCueForPlayback
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class USoundCue* SoundCue (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UAudioMixerBlueprintLibrary::PrimeSoundCueForPlayback(class USoundCue* SoundCue)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("AudioMixerBlueprintLibrary", "PrimeSoundCueForPlayback");
|
|
|
|
Params::UAudioMixerBlueprintLibrary_PrimeSoundCueForPlayback_Params Parms{};
|
|
|
|
Parms.SoundCue = SoundCue;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
}
|
|
|
|
|
|
// Function AudioMixer.AudioMixerBlueprintLibrary.PauseRecordingOutput
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class USoundSubmix* SubmixToPause (Parm, ZeroConstructor, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UAudioMixerBlueprintLibrary::PauseRecordingOutput(class UObject* WorldContextObject, class USoundSubmix* SubmixToPause)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("AudioMixerBlueprintLibrary", "PauseRecordingOutput");
|
|
|
|
Params::UAudioMixerBlueprintLibrary_PauseRecordingOutput_Params Parms{};
|
|
|
|
Parms.WorldContextObject = WorldContextObject;
|
|
Parms.SubmixToPause = SubmixToPause;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
}
|
|
|
|
|
|
// Function AudioMixer.AudioMixerBlueprintLibrary.MakePresetSpectralAnalysisBandSettings
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// enum class EAudioSpectrumBandPresetTypeInBandPresetType (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// int32 InNumBands (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// int32 InAttackTimeMsec (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// int32 InReleaseTimeMsec (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// TArray<struct FSoundSubmixSpectralAnalysisBandSettings>ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)
|
|
|
|
TArray<struct FSoundSubmixSpectralAnalysisBandSettings> UAudioMixerBlueprintLibrary::MakePresetSpectralAnalysisBandSettings(enum class EAudioSpectrumBandPresetType InBandPresetType, int32 InNumBands, int32 InAttackTimeMsec, int32 InReleaseTimeMsec)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("AudioMixerBlueprintLibrary", "MakePresetSpectralAnalysisBandSettings");
|
|
|
|
Params::UAudioMixerBlueprintLibrary_MakePresetSpectralAnalysisBandSettings_Params Parms{};
|
|
|
|
Parms.InBandPresetType = InBandPresetType;
|
|
Parms.InNumBands = InNumBands;
|
|
Parms.InAttackTimeMsec = InAttackTimeMsec;
|
|
Parms.InReleaseTimeMsec = InReleaseTimeMsec;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function AudioMixer.AudioMixerBlueprintLibrary.MakeMusicalSpectralAnalysisBandSettings
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// int32 InNumSemitones (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// enum class EMusicalNoteName InStartingMusicalNote (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// int32 InStartingOctave (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// int32 InAttackTimeMsec (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// int32 InReleaseTimeMsec (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// TArray<struct FSoundSubmixSpectralAnalysisBandSettings>ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)
|
|
|
|
TArray<struct FSoundSubmixSpectralAnalysisBandSettings> UAudioMixerBlueprintLibrary::MakeMusicalSpectralAnalysisBandSettings(int32 InNumSemitones, enum class EMusicalNoteName InStartingMusicalNote, int32 InStartingOctave, int32 InAttackTimeMsec, int32 InReleaseTimeMsec)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("AudioMixerBlueprintLibrary", "MakeMusicalSpectralAnalysisBandSettings");
|
|
|
|
Params::UAudioMixerBlueprintLibrary_MakeMusicalSpectralAnalysisBandSettings_Params Parms{};
|
|
|
|
Parms.InNumSemitones = InNumSemitones;
|
|
Parms.InStartingMusicalNote = InStartingMusicalNote;
|
|
Parms.InStartingOctave = InStartingOctave;
|
|
Parms.InAttackTimeMsec = InAttackTimeMsec;
|
|
Parms.InReleaseTimeMsec = InReleaseTimeMsec;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function AudioMixer.AudioMixerBlueprintLibrary.MakeFullSpectrumSpectralAnalysisBandSettings
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// int32 InNumBands (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float InMinimumFrequency (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float InMaximumFrequency (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// int32 InAttackTimeMsec (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// int32 InReleaseTimeMsec (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// TArray<struct FSoundSubmixSpectralAnalysisBandSettings>ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)
|
|
|
|
TArray<struct FSoundSubmixSpectralAnalysisBandSettings> UAudioMixerBlueprintLibrary::MakeFullSpectrumSpectralAnalysisBandSettings(int32 InNumBands, float InMinimumFrequency, float InMaximumFrequency, int32 InAttackTimeMsec, int32 InReleaseTimeMsec)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("AudioMixerBlueprintLibrary", "MakeFullSpectrumSpectralAnalysisBandSettings");
|
|
|
|
Params::UAudioMixerBlueprintLibrary_MakeFullSpectrumSpectralAnalysisBandSettings_Params Parms{};
|
|
|
|
Parms.InNumBands = InNumBands;
|
|
Parms.InMinimumFrequency = InMinimumFrequency;
|
|
Parms.InMaximumFrequency = InMaximumFrequency;
|
|
Parms.InAttackTimeMsec = InAttackTimeMsec;
|
|
Parms.InReleaseTimeMsec = InReleaseTimeMsec;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function AudioMixer.AudioMixerBlueprintLibrary.IsAudioBusActive
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class UAudioBus* AudioBus (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
bool UAudioMixerBlueprintLibrary::IsAudioBusActive(class UObject* WorldContextObject, class UAudioBus* AudioBus)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("AudioMixerBlueprintLibrary", "IsAudioBusActive");
|
|
|
|
Params::UAudioMixerBlueprintLibrary_IsAudioBusActive_Params Parms{};
|
|
|
|
Parms.WorldContextObject = WorldContextObject;
|
|
Parms.AudioBus = AudioBus;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function AudioMixer.AudioMixerBlueprintLibrary.GetPhaseForFrequencies
|
|
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// TArray<float> Frequencies (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
|
|
// TArray<float> Phases (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)
|
|
// class USoundSubmix* SubmixToAnalyze (Parm, ZeroConstructor, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UAudioMixerBlueprintLibrary::GetPhaseForFrequencies(class UObject* WorldContextObject, TArray<float>& Frequencies, TArray<float>* Phases, class USoundSubmix* SubmixToAnalyze)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("AudioMixerBlueprintLibrary", "GetPhaseForFrequencies");
|
|
|
|
Params::UAudioMixerBlueprintLibrary_GetPhaseForFrequencies_Params Parms{};
|
|
|
|
Parms.WorldContextObject = WorldContextObject;
|
|
Parms.Frequencies = Frequencies;
|
|
Parms.SubmixToAnalyze = SubmixToAnalyze;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
if (Phases != nullptr)
|
|
*Phases = std::move(Parms.Phases);
|
|
|
|
}
|
|
|
|
|
|
// Function AudioMixer.AudioMixerBlueprintLibrary.GetNumberOfEntriesInSourceEffectChain
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class USoundEffectSourcePresetChain*PresetChain (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// int32 ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
int32 UAudioMixerBlueprintLibrary::GetNumberOfEntriesInSourceEffectChain(class UObject* WorldContextObject, class USoundEffectSourcePresetChain* PresetChain)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("AudioMixerBlueprintLibrary", "GetNumberOfEntriesInSourceEffectChain");
|
|
|
|
Params::UAudioMixerBlueprintLibrary_GetNumberOfEntriesInSourceEffectChain_Params Parms{};
|
|
|
|
Parms.WorldContextObject = WorldContextObject;
|
|
Parms.PresetChain = PresetChain;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function AudioMixer.AudioMixerBlueprintLibrary.GetMagnitudeForFrequencies
|
|
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// TArray<float> Frequencies (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
|
|
// TArray<float> Magnitudes (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)
|
|
// class USoundSubmix* SubmixToAnalyze (Parm, ZeroConstructor, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UAudioMixerBlueprintLibrary::GetMagnitudeForFrequencies(class UObject* WorldContextObject, TArray<float>& Frequencies, TArray<float>* Magnitudes, class USoundSubmix* SubmixToAnalyze)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("AudioMixerBlueprintLibrary", "GetMagnitudeForFrequencies");
|
|
|
|
Params::UAudioMixerBlueprintLibrary_GetMagnitudeForFrequencies_Params Parms{};
|
|
|
|
Parms.WorldContextObject = WorldContextObject;
|
|
Parms.Frequencies = Frequencies;
|
|
Parms.SubmixToAnalyze = SubmixToAnalyze;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
if (Magnitudes != nullptr)
|
|
*Magnitudes = std::move(Parms.Magnitudes);
|
|
|
|
}
|
|
|
|
|
|
// Function AudioMixer.AudioMixerBlueprintLibrary.GetCurrentAudioOutputDeviceName
|
|
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// FDelegateProperty_ OnObtainCurrentDeviceEvent (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UAudioMixerBlueprintLibrary::GetCurrentAudioOutputDeviceName(class UObject* WorldContextObject, FDelegateProperty_& OnObtainCurrentDeviceEvent)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("AudioMixerBlueprintLibrary", "GetCurrentAudioOutputDeviceName");
|
|
|
|
Params::UAudioMixerBlueprintLibrary_GetCurrentAudioOutputDeviceName_Params Parms{};
|
|
|
|
Parms.WorldContextObject = WorldContextObject;
|
|
Parms.OnObtainCurrentDeviceEvent = OnObtainCurrentDeviceEvent;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
}
|
|
|
|
|
|
// Function AudioMixer.AudioMixerBlueprintLibrary.GetAvailableAudioOutputDevices
|
|
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// FDelegateProperty_ OnObtainDevicesEvent (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UAudioMixerBlueprintLibrary::GetAvailableAudioOutputDevices(class UObject* WorldContextObject, FDelegateProperty_& OnObtainDevicesEvent)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("AudioMixerBlueprintLibrary", "GetAvailableAudioOutputDevices");
|
|
|
|
Params::UAudioMixerBlueprintLibrary_GetAvailableAudioOutputDevices_Params Parms{};
|
|
|
|
Parms.WorldContextObject = WorldContextObject;
|
|
Parms.OnObtainDevicesEvent = OnObtainDevicesEvent;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
}
|
|
|
|
|
|
// Function AudioMixer.AudioMixerBlueprintLibrary.Conv_AudioOutputDeviceInfoToString
|
|
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FAudioOutputDeviceInfo Info (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
|
|
// class FString ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
class FString UAudioMixerBlueprintLibrary::Conv_AudioOutputDeviceInfoToString(struct FAudioOutputDeviceInfo& Info)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("AudioMixerBlueprintLibrary", "Conv_AudioOutputDeviceInfoToString");
|
|
|
|
Params::UAudioMixerBlueprintLibrary_Conv_AudioOutputDeviceInfoToString_Params Parms{};
|
|
|
|
Parms.Info = Info;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function AudioMixer.AudioMixerBlueprintLibrary.ClearSubmixEffects
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class USoundSubmix* SoundSubmix (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UAudioMixerBlueprintLibrary::ClearSubmixEffects(class UObject* WorldContextObject, class USoundSubmix* SoundSubmix)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("AudioMixerBlueprintLibrary", "ClearSubmixEffects");
|
|
|
|
Params::UAudioMixerBlueprintLibrary_ClearSubmixEffects_Params Parms{};
|
|
|
|
Parms.WorldContextObject = WorldContextObject;
|
|
Parms.SoundSubmix = SoundSubmix;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
}
|
|
|
|
|
|
// Function AudioMixer.AudioMixerBlueprintLibrary.ClearSubmixEffectChainOverride
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class USoundSubmix* SoundSubmix (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float FadeTimeSec (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UAudioMixerBlueprintLibrary::ClearSubmixEffectChainOverride(class UObject* WorldContextObject, class USoundSubmix* SoundSubmix, float FadeTimeSec)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("AudioMixerBlueprintLibrary", "ClearSubmixEffectChainOverride");
|
|
|
|
Params::UAudioMixerBlueprintLibrary_ClearSubmixEffectChainOverride_Params Parms{};
|
|
|
|
Parms.WorldContextObject = WorldContextObject;
|
|
Parms.SoundSubmix = SoundSubmix;
|
|
Parms.FadeTimeSec = FadeTimeSec;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
}
|
|
|
|
|
|
// Function AudioMixer.AudioMixerBlueprintLibrary.ClearMasterSubmixEffects
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UAudioMixerBlueprintLibrary::ClearMasterSubmixEffects(class UObject* WorldContextObject)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("AudioMixerBlueprintLibrary", "ClearMasterSubmixEffects");
|
|
|
|
Params::UAudioMixerBlueprintLibrary_ClearMasterSubmixEffects_Params Parms{};
|
|
|
|
Parms.WorldContextObject = WorldContextObject;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
}
|
|
|
|
|
|
// Function AudioMixer.AudioMixerBlueprintLibrary.AddSubmixEffect
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class USoundSubmix* SoundSubmix (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class USoundEffectSubmixPreset* SubmixEffectPreset (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// int32 ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
int32 UAudioMixerBlueprintLibrary::AddSubmixEffect(class UObject* WorldContextObject, class USoundSubmix* SoundSubmix, class USoundEffectSubmixPreset* SubmixEffectPreset)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("AudioMixerBlueprintLibrary", "AddSubmixEffect");
|
|
|
|
Params::UAudioMixerBlueprintLibrary_AddSubmixEffect_Params Parms{};
|
|
|
|
Parms.WorldContextObject = WorldContextObject;
|
|
Parms.SoundSubmix = SoundSubmix;
|
|
Parms.SubmixEffectPreset = SubmixEffectPreset;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function AudioMixer.AudioMixerBlueprintLibrary.AddSourceEffectToPresetChain
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class USoundEffectSourcePresetChain*PresetChain (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// struct FSourceEffectChainEntry Entry (Parm, NoDestructor, NativeAccessSpecifierPublic)
|
|
|
|
void UAudioMixerBlueprintLibrary::AddSourceEffectToPresetChain(class UObject* WorldContextObject, class USoundEffectSourcePresetChain* PresetChain, const struct FSourceEffectChainEntry& Entry)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("AudioMixerBlueprintLibrary", "AddSourceEffectToPresetChain");
|
|
|
|
Params::UAudioMixerBlueprintLibrary_AddSourceEffectToPresetChain_Params Parms{};
|
|
|
|
Parms.WorldContextObject = WorldContextObject;
|
|
Parms.PresetChain = PresetChain;
|
|
Parms.Entry = Entry;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
}
|
|
|
|
|
|
// Function AudioMixer.AudioMixerBlueprintLibrary.AddMasterSubmixEffect
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class USoundEffectSubmixPreset* SubmixEffectPreset (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UAudioMixerBlueprintLibrary::AddMasterSubmixEffect(class UObject* WorldContextObject, class USoundEffectSubmixPreset* SubmixEffectPreset)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("AudioMixerBlueprintLibrary", "AddMasterSubmixEffect");
|
|
|
|
Params::UAudioMixerBlueprintLibrary_AddMasterSubmixEffect_Params Parms{};
|
|
|
|
Parms.WorldContextObject = WorldContextObject;
|
|
Parms.SubmixEffectPreset = SubmixEffectPreset;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
}
|
|
|
|
|
|
// Class AudioMixer.SynthSound
|
|
// (None)
|
|
|
|
class UClass* USynthSound::StaticClass()
|
|
{
|
|
static class UClass* Clss = nullptr;
|
|
|
|
if (!Clss)
|
|
Clss = UObject::FindClassFast("SynthSound");
|
|
|
|
return Clss;
|
|
}
|
|
|
|
|
|
// SynthSound AudioMixer.Default__SynthSound
|
|
// (Public, ClassDefaultObject, ArchetypeObject)
|
|
|
|
class USynthSound* USynthSound::GetDefaultObj()
|
|
{
|
|
static class USynthSound* Default = nullptr;
|
|
|
|
if (!Default)
|
|
Default = static_cast<USynthSound*>(USynthSound::StaticClass()->DefaultObject);
|
|
|
|
return Default;
|
|
}
|
|
|
|
|
|
// Class AudioMixer.SubmixEffectDynamicsProcessorPreset
|
|
// (None)
|
|
|
|
class UClass* USubmixEffectDynamicsProcessorPreset::StaticClass()
|
|
{
|
|
static class UClass* Clss = nullptr;
|
|
|
|
if (!Clss)
|
|
Clss = UObject::FindClassFast("SubmixEffectDynamicsProcessorPreset");
|
|
|
|
return Clss;
|
|
}
|
|
|
|
|
|
// SubmixEffectDynamicsProcessorPreset AudioMixer.Default__SubmixEffectDynamicsProcessorPreset
|
|
// (Public, ClassDefaultObject, ArchetypeObject)
|
|
|
|
class USubmixEffectDynamicsProcessorPreset* USubmixEffectDynamicsProcessorPreset::GetDefaultObj()
|
|
{
|
|
static class USubmixEffectDynamicsProcessorPreset* Default = nullptr;
|
|
|
|
if (!Default)
|
|
Default = static_cast<USubmixEffectDynamicsProcessorPreset*>(USubmixEffectDynamicsProcessorPreset::StaticClass()->DefaultObject);
|
|
|
|
return Default;
|
|
}
|
|
|
|
|
|
// Function AudioMixer.SubmixEffectDynamicsProcessorPreset.SetSettings
|
|
// (Final, Native, Public, HasOutParams, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FSubmixEffectDynamicsProcessorSettingsSettings (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
|
|
void USubmixEffectDynamicsProcessorPreset::SetSettings(struct FSubmixEffectDynamicsProcessorSettings& Settings)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("SubmixEffectDynamicsProcessorPreset", "SetSettings");
|
|
|
|
Params::USubmixEffectDynamicsProcessorPreset_SetSettings_Params Parms{};
|
|
|
|
Parms.Settings = Settings;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
}
|
|
|
|
|
|
// Function AudioMixer.SubmixEffectDynamicsProcessorPreset.SetExternalSubmix
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class USoundSubmix* Submix (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void USubmixEffectDynamicsProcessorPreset::SetExternalSubmix(class USoundSubmix* Submix)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("SubmixEffectDynamicsProcessorPreset", "SetExternalSubmix");
|
|
|
|
Params::USubmixEffectDynamicsProcessorPreset_SetExternalSubmix_Params Parms{};
|
|
|
|
Parms.Submix = Submix;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
}
|
|
|
|
|
|
// Function AudioMixer.SubmixEffectDynamicsProcessorPreset.SetAudioBus
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UAudioBus* AudioBus (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void USubmixEffectDynamicsProcessorPreset::SetAudioBus(class UAudioBus* AudioBus)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("SubmixEffectDynamicsProcessorPreset", "SetAudioBus");
|
|
|
|
Params::USubmixEffectDynamicsProcessorPreset_SetAudioBus_Params Parms{};
|
|
|
|
Parms.AudioBus = AudioBus;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
}
|
|
|
|
|
|
// Function AudioMixer.SubmixEffectDynamicsProcessorPreset.ResetKey
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
|
|
void USubmixEffectDynamicsProcessorPreset::ResetKey()
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("SubmixEffectDynamicsProcessorPreset", "ResetKey");
|
|
|
|
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, nullptr);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
}
|
|
|
|
|
|
// Class AudioMixer.SubmixEffectSubmixEQPreset
|
|
// (None)
|
|
|
|
class UClass* USubmixEffectSubmixEQPreset::StaticClass()
|
|
{
|
|
static class UClass* Clss = nullptr;
|
|
|
|
if (!Clss)
|
|
Clss = UObject::FindClassFast("SubmixEffectSubmixEQPreset");
|
|
|
|
return Clss;
|
|
}
|
|
|
|
|
|
// SubmixEffectSubmixEQPreset AudioMixer.Default__SubmixEffectSubmixEQPreset
|
|
// (Public, ClassDefaultObject, ArchetypeObject)
|
|
|
|
class USubmixEffectSubmixEQPreset* USubmixEffectSubmixEQPreset::GetDefaultObj()
|
|
{
|
|
static class USubmixEffectSubmixEQPreset* Default = nullptr;
|
|
|
|
if (!Default)
|
|
Default = static_cast<USubmixEffectSubmixEQPreset*>(USubmixEffectSubmixEQPreset::StaticClass()->DefaultObject);
|
|
|
|
return Default;
|
|
}
|
|
|
|
|
|
// Function AudioMixer.SubmixEffectSubmixEQPreset.SetSettings
|
|
// (Final, Native, Public, HasOutParams, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FSubmixEffectSubmixEQSettingsInSettings (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
|
|
|
|
void USubmixEffectSubmixEQPreset::SetSettings(struct FSubmixEffectSubmixEQSettings& InSettings)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("SubmixEffectSubmixEQPreset", "SetSettings");
|
|
|
|
Params::USubmixEffectSubmixEQPreset_SetSettings_Params Parms{};
|
|
|
|
Parms.InSettings = InSettings;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
}
|
|
|
|
|
|
// Class AudioMixer.SubmixEffectReverbPreset
|
|
// (None)
|
|
|
|
class UClass* USubmixEffectReverbPreset::StaticClass()
|
|
{
|
|
static class UClass* Clss = nullptr;
|
|
|
|
if (!Clss)
|
|
Clss = UObject::FindClassFast("SubmixEffectReverbPreset");
|
|
|
|
return Clss;
|
|
}
|
|
|
|
|
|
// SubmixEffectReverbPreset AudioMixer.Default__SubmixEffectReverbPreset
|
|
// (Public, ClassDefaultObject, ArchetypeObject)
|
|
|
|
class USubmixEffectReverbPreset* USubmixEffectReverbPreset::GetDefaultObj()
|
|
{
|
|
static class USubmixEffectReverbPreset* Default = nullptr;
|
|
|
|
if (!Default)
|
|
Default = static_cast<USubmixEffectReverbPreset*>(USubmixEffectReverbPreset::StaticClass()->DefaultObject);
|
|
|
|
return Default;
|
|
}
|
|
|
|
|
|
// Function AudioMixer.SubmixEffectReverbPreset.SetSettingsWithReverbEffect
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UReverbEffect* InReverbEffect (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float WetLevel (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float DryLevel (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void USubmixEffectReverbPreset::SetSettingsWithReverbEffect(class UReverbEffect* InReverbEffect, float WetLevel, float DryLevel)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("SubmixEffectReverbPreset", "SetSettingsWithReverbEffect");
|
|
|
|
Params::USubmixEffectReverbPreset_SetSettingsWithReverbEffect_Params Parms{};
|
|
|
|
Parms.InReverbEffect = InReverbEffect;
|
|
Parms.WetLevel = WetLevel;
|
|
Parms.DryLevel = DryLevel;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
}
|
|
|
|
|
|
// Function AudioMixer.SubmixEffectReverbPreset.SetSettings
|
|
// (Final, Native, Public, HasOutParams, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FSubmixEffectReverbSettings InSettings (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
|
|
void USubmixEffectReverbPreset::SetSettings(struct FSubmixEffectReverbSettings& InSettings)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("SubmixEffectReverbPreset", "SetSettings");
|
|
|
|
Params::USubmixEffectReverbPreset_SetSettings_Params Parms{};
|
|
|
|
Parms.InSettings = InSettings;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
}
|
|
|
|
|
|
// Class AudioMixer.QuartzClockHandle
|
|
// (None)
|
|
|
|
class UClass* UQuartzClockHandle::StaticClass()
|
|
{
|
|
static class UClass* Clss = nullptr;
|
|
|
|
if (!Clss)
|
|
Clss = UObject::FindClassFast("QuartzClockHandle");
|
|
|
|
return Clss;
|
|
}
|
|
|
|
|
|
// QuartzClockHandle AudioMixer.Default__QuartzClockHandle
|
|
// (Public, ClassDefaultObject, ArchetypeObject)
|
|
|
|
class UQuartzClockHandle* UQuartzClockHandle::GetDefaultObj()
|
|
{
|
|
static class UQuartzClockHandle* Default = nullptr;
|
|
|
|
if (!Default)
|
|
Default = static_cast<UQuartzClockHandle*>(UQuartzClockHandle::StaticClass()->DefaultObject);
|
|
|
|
return Default;
|
|
}
|
|
|
|
|
|
// Function AudioMixer.QuartzClockHandle.UnsubscribeFromTimeDivision
|
|
// (Final, Native, Public, HasOutParams, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// enum class EQuartzCommandQuantizationInQuantizationBoundary (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class UQuartzClockHandle* ClockHandle (Parm, OutParm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UQuartzClockHandle::UnsubscribeFromTimeDivision(class UObject* WorldContextObject, enum class EQuartzCommandQuantization InQuantizationBoundary, class UQuartzClockHandle** ClockHandle)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("QuartzClockHandle", "UnsubscribeFromTimeDivision");
|
|
|
|
Params::UQuartzClockHandle_UnsubscribeFromTimeDivision_Params Parms{};
|
|
|
|
Parms.WorldContextObject = WorldContextObject;
|
|
Parms.InQuantizationBoundary = InQuantizationBoundary;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
if (ClockHandle != nullptr)
|
|
*ClockHandle = Parms.ClockHandle;
|
|
|
|
}
|
|
|
|
|
|
// Function AudioMixer.QuartzClockHandle.UnsubscribeFromAllTimeDivisions
|
|
// (Final, Native, Public, HasOutParams, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class UQuartzClockHandle* ClockHandle (Parm, OutParm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UQuartzClockHandle::UnsubscribeFromAllTimeDivisions(class UObject* WorldContextObject, class UQuartzClockHandle** ClockHandle)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("QuartzClockHandle", "UnsubscribeFromAllTimeDivisions");
|
|
|
|
Params::UQuartzClockHandle_UnsubscribeFromAllTimeDivisions_Params Parms{};
|
|
|
|
Parms.WorldContextObject = WorldContextObject;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
if (ClockHandle != nullptr)
|
|
*ClockHandle = Parms.ClockHandle;
|
|
|
|
}
|
|
|
|
|
|
// Function AudioMixer.QuartzClockHandle.SubscribeToQuantizationEvent
|
|
// (Final, Native, Public, HasOutParams, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// enum class EQuartzCommandQuantizationInQuantizationBoundary (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// FDelegateProperty_ OnQuantizationEvent (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class UQuartzClockHandle* ClockHandle (Parm, OutParm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UQuartzClockHandle::SubscribeToQuantizationEvent(class UObject* WorldContextObject, enum class EQuartzCommandQuantization InQuantizationBoundary, FDelegateProperty_& OnQuantizationEvent, class UQuartzClockHandle** ClockHandle)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("QuartzClockHandle", "SubscribeToQuantizationEvent");
|
|
|
|
Params::UQuartzClockHandle_SubscribeToQuantizationEvent_Params Parms{};
|
|
|
|
Parms.WorldContextObject = WorldContextObject;
|
|
Parms.InQuantizationBoundary = InQuantizationBoundary;
|
|
Parms.OnQuantizationEvent = OnQuantizationEvent;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
if (ClockHandle != nullptr)
|
|
*ClockHandle = Parms.ClockHandle;
|
|
|
|
}
|
|
|
|
|
|
// Function AudioMixer.QuartzClockHandle.SubscribeToAllQuantizationEvents
|
|
// (Final, Native, Public, HasOutParams, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// FDelegateProperty_ OnQuantizationEvent (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class UQuartzClockHandle* ClockHandle (Parm, OutParm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UQuartzClockHandle::SubscribeToAllQuantizationEvents(class UObject* WorldContextObject, FDelegateProperty_& OnQuantizationEvent, class UQuartzClockHandle** ClockHandle)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("QuartzClockHandle", "SubscribeToAllQuantizationEvents");
|
|
|
|
Params::UQuartzClockHandle_SubscribeToAllQuantizationEvents_Params Parms{};
|
|
|
|
Parms.WorldContextObject = WorldContextObject;
|
|
Parms.OnQuantizationEvent = OnQuantizationEvent;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
if (ClockHandle != nullptr)
|
|
*ClockHandle = Parms.ClockHandle;
|
|
|
|
}
|
|
|
|
|
|
// Function AudioMixer.QuartzClockHandle.StopClock
|
|
// (Final, Native, Public, HasOutParams, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// bool CancelPendingEvents (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class UQuartzClockHandle* ClockHandle (Parm, OutParm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UQuartzClockHandle::StopClock(class UObject* WorldContextObject, bool CancelPendingEvents, class UQuartzClockHandle** ClockHandle)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("QuartzClockHandle", "StopClock");
|
|
|
|
Params::UQuartzClockHandle_StopClock_Params Parms{};
|
|
|
|
Parms.WorldContextObject = WorldContextObject;
|
|
Parms.CancelPendingEvents = CancelPendingEvents;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
if (ClockHandle != nullptr)
|
|
*ClockHandle = Parms.ClockHandle;
|
|
|
|
}
|
|
|
|
|
|
// Function AudioMixer.QuartzClockHandle.StartOtherClock
|
|
// (Final, Native, Public, HasOutParams, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class FName OtherClockName (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// struct FQuartzQuantizationBoundary InQuantizationBoundary (Parm, NativeAccessSpecifierPublic)
|
|
// FDelegateProperty_ InDelegate (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UQuartzClockHandle::StartOtherClock(class UObject* WorldContextObject, class FName OtherClockName, const struct FQuartzQuantizationBoundary& InQuantizationBoundary, FDelegateProperty_& InDelegate)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("QuartzClockHandle", "StartOtherClock");
|
|
|
|
Params::UQuartzClockHandle_StartOtherClock_Params Parms{};
|
|
|
|
Parms.WorldContextObject = WorldContextObject;
|
|
Parms.OtherClockName = OtherClockName;
|
|
Parms.InQuantizationBoundary = InQuantizationBoundary;
|
|
Parms.InDelegate = InDelegate;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
}
|
|
|
|
|
|
// Function AudioMixer.QuartzClockHandle.StartClock
|
|
// (Final, Native, Public, HasOutParams, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class UQuartzClockHandle* ClockHandle (Parm, OutParm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UQuartzClockHandle::StartClock(class UObject* WorldContextObject, class UQuartzClockHandle** ClockHandle)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("QuartzClockHandle", "StartClock");
|
|
|
|
Params::UQuartzClockHandle_StartClock_Params Parms{};
|
|
|
|
Parms.WorldContextObject = WorldContextObject;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
if (ClockHandle != nullptr)
|
|
*ClockHandle = Parms.ClockHandle;
|
|
|
|
}
|
|
|
|
|
|
// Function AudioMixer.QuartzClockHandle.SetTicksPerSecond
|
|
// (Final, Native, Public, HasOutParams, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// struct FQuartzQuantizationBoundary QuantizationBoundary (ConstParm, Parm, OutParm, ReferenceParm, AdvancedDisplay, NativeAccessSpecifierPublic)
|
|
// FDelegateProperty_ Delegate (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class UQuartzClockHandle* ClockHandle (Parm, OutParm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float TicksPerSecond (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UQuartzClockHandle::SetTicksPerSecond(class UObject* WorldContextObject, struct FQuartzQuantizationBoundary& QuantizationBoundary, FDelegateProperty_& Delegate, class UQuartzClockHandle** ClockHandle, float TicksPerSecond)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("QuartzClockHandle", "SetTicksPerSecond");
|
|
|
|
Params::UQuartzClockHandle_SetTicksPerSecond_Params Parms{};
|
|
|
|
Parms.WorldContextObject = WorldContextObject;
|
|
Parms.QuantizationBoundary = QuantizationBoundary;
|
|
Parms.Delegate = Delegate;
|
|
Parms.TicksPerSecond = TicksPerSecond;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
if (ClockHandle != nullptr)
|
|
*ClockHandle = Parms.ClockHandle;
|
|
|
|
}
|
|
|
|
|
|
// Function AudioMixer.QuartzClockHandle.SetThirtySecondNotesPerMinute
|
|
// (Final, Native, Public, HasOutParams, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// struct FQuartzQuantizationBoundary QuantizationBoundary (ConstParm, Parm, OutParm, ReferenceParm, AdvancedDisplay, NativeAccessSpecifierPublic)
|
|
// FDelegateProperty_ Delegate (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class UQuartzClockHandle* ClockHandle (Parm, OutParm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float ThirtySecondsNotesPerMinute (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UQuartzClockHandle::SetThirtySecondNotesPerMinute(class UObject* WorldContextObject, struct FQuartzQuantizationBoundary& QuantizationBoundary, FDelegateProperty_& Delegate, class UQuartzClockHandle** ClockHandle, float ThirtySecondsNotesPerMinute)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("QuartzClockHandle", "SetThirtySecondNotesPerMinute");
|
|
|
|
Params::UQuartzClockHandle_SetThirtySecondNotesPerMinute_Params Parms{};
|
|
|
|
Parms.WorldContextObject = WorldContextObject;
|
|
Parms.QuantizationBoundary = QuantizationBoundary;
|
|
Parms.Delegate = Delegate;
|
|
Parms.ThirtySecondsNotesPerMinute = ThirtySecondsNotesPerMinute;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
if (ClockHandle != nullptr)
|
|
*ClockHandle = Parms.ClockHandle;
|
|
|
|
}
|
|
|
|
|
|
// Function AudioMixer.QuartzClockHandle.SetSecondsPerTick
|
|
// (Final, Native, Public, HasOutParams, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// struct FQuartzQuantizationBoundary QuantizationBoundary (ConstParm, Parm, OutParm, ReferenceParm, AdvancedDisplay, NativeAccessSpecifierPublic)
|
|
// FDelegateProperty_ Delegate (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class UQuartzClockHandle* ClockHandle (Parm, OutParm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float SecondsPerTick (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UQuartzClockHandle::SetSecondsPerTick(class UObject* WorldContextObject, struct FQuartzQuantizationBoundary& QuantizationBoundary, FDelegateProperty_& Delegate, class UQuartzClockHandle** ClockHandle, float SecondsPerTick)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("QuartzClockHandle", "SetSecondsPerTick");
|
|
|
|
Params::UQuartzClockHandle_SetSecondsPerTick_Params Parms{};
|
|
|
|
Parms.WorldContextObject = WorldContextObject;
|
|
Parms.QuantizationBoundary = QuantizationBoundary;
|
|
Parms.Delegate = Delegate;
|
|
Parms.SecondsPerTick = SecondsPerTick;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
if (ClockHandle != nullptr)
|
|
*ClockHandle = Parms.ClockHandle;
|
|
|
|
}
|
|
|
|
|
|
// Function AudioMixer.QuartzClockHandle.SetMillisecondsPerTick
|
|
// (Final, Native, Public, HasOutParams, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// struct FQuartzQuantizationBoundary QuantizationBoundary (ConstParm, Parm, OutParm, ReferenceParm, AdvancedDisplay, NativeAccessSpecifierPublic)
|
|
// FDelegateProperty_ Delegate (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class UQuartzClockHandle* ClockHandle (Parm, OutParm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float MillisecondsPerTick (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UQuartzClockHandle::SetMillisecondsPerTick(class UObject* WorldContextObject, struct FQuartzQuantizationBoundary& QuantizationBoundary, FDelegateProperty_& Delegate, class UQuartzClockHandle** ClockHandle, float MillisecondsPerTick)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("QuartzClockHandle", "SetMillisecondsPerTick");
|
|
|
|
Params::UQuartzClockHandle_SetMillisecondsPerTick_Params Parms{};
|
|
|
|
Parms.WorldContextObject = WorldContextObject;
|
|
Parms.QuantizationBoundary = QuantizationBoundary;
|
|
Parms.Delegate = Delegate;
|
|
Parms.MillisecondsPerTick = MillisecondsPerTick;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
if (ClockHandle != nullptr)
|
|
*ClockHandle = Parms.ClockHandle;
|
|
|
|
}
|
|
|
|
|
|
// Function AudioMixer.QuartzClockHandle.SetBeatsPerMinute
|
|
// (Final, Native, Public, HasOutParams, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// struct FQuartzQuantizationBoundary QuantizationBoundary (ConstParm, Parm, OutParm, ReferenceParm, AdvancedDisplay, NativeAccessSpecifierPublic)
|
|
// FDelegateProperty_ Delegate (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class UQuartzClockHandle* ClockHandle (Parm, OutParm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float BeatsPerMinute (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UQuartzClockHandle::SetBeatsPerMinute(class UObject* WorldContextObject, struct FQuartzQuantizationBoundary& QuantizationBoundary, FDelegateProperty_& Delegate, class UQuartzClockHandle** ClockHandle, float BeatsPerMinute)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("QuartzClockHandle", "SetBeatsPerMinute");
|
|
|
|
Params::UQuartzClockHandle_SetBeatsPerMinute_Params Parms{};
|
|
|
|
Parms.WorldContextObject = WorldContextObject;
|
|
Parms.QuantizationBoundary = QuantizationBoundary;
|
|
Parms.Delegate = Delegate;
|
|
Parms.BeatsPerMinute = BeatsPerMinute;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
if (ClockHandle != nullptr)
|
|
*ClockHandle = Parms.ClockHandle;
|
|
|
|
}
|
|
|
|
|
|
// Function AudioMixer.QuartzClockHandle.ResumeClock
|
|
// (Final, Native, Public, HasOutParams, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class UQuartzClockHandle* ClockHandle (Parm, OutParm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UQuartzClockHandle::ResumeClock(class UObject* WorldContextObject, class UQuartzClockHandle** ClockHandle)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("QuartzClockHandle", "ResumeClock");
|
|
|
|
Params::UQuartzClockHandle_ResumeClock_Params Parms{};
|
|
|
|
Parms.WorldContextObject = WorldContextObject;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
if (ClockHandle != nullptr)
|
|
*ClockHandle = Parms.ClockHandle;
|
|
|
|
}
|
|
|
|
|
|
// Function AudioMixer.QuartzClockHandle.ResetTransportQuantized
|
|
// (Final, Native, Public, HasOutParams, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// struct FQuartzQuantizationBoundary InQuantizationBoundary (Parm, NativeAccessSpecifierPublic)
|
|
// FDelegateProperty_ InDelegate (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class UQuartzClockHandle* ClockHandle (Parm, OutParm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UQuartzClockHandle::ResetTransportQuantized(class UObject* WorldContextObject, const struct FQuartzQuantizationBoundary& InQuantizationBoundary, FDelegateProperty_& InDelegate, class UQuartzClockHandle** ClockHandle)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("QuartzClockHandle", "ResetTransportQuantized");
|
|
|
|
Params::UQuartzClockHandle_ResetTransportQuantized_Params Parms{};
|
|
|
|
Parms.WorldContextObject = WorldContextObject;
|
|
Parms.InQuantizationBoundary = InQuantizationBoundary;
|
|
Parms.InDelegate = InDelegate;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
if (ClockHandle != nullptr)
|
|
*ClockHandle = Parms.ClockHandle;
|
|
|
|
}
|
|
|
|
|
|
// Function AudioMixer.QuartzClockHandle.ResetTransport
|
|
// (Final, Native, Public, HasOutParams, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// FDelegateProperty_ InDelegate (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UQuartzClockHandle::ResetTransport(class UObject* WorldContextObject, FDelegateProperty_& InDelegate)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("QuartzClockHandle", "ResetTransport");
|
|
|
|
Params::UQuartzClockHandle_ResetTransport_Params Parms{};
|
|
|
|
Parms.WorldContextObject = WorldContextObject;
|
|
Parms.InDelegate = InDelegate;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
}
|
|
|
|
|
|
// Function AudioMixer.QuartzClockHandle.PauseClock
|
|
// (Final, Native, Public, HasOutParams, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class UQuartzClockHandle* ClockHandle (Parm, OutParm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UQuartzClockHandle::PauseClock(class UObject* WorldContextObject, class UQuartzClockHandle** ClockHandle)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("QuartzClockHandle", "PauseClock");
|
|
|
|
Params::UQuartzClockHandle_PauseClock_Params Parms{};
|
|
|
|
Parms.WorldContextObject = WorldContextObject;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
if (ClockHandle != nullptr)
|
|
*ClockHandle = Parms.ClockHandle;
|
|
|
|
}
|
|
|
|
|
|
// Function AudioMixer.QuartzClockHandle.IsClockRunning
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
bool UQuartzClockHandle::IsClockRunning(class UObject* WorldContextObject)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("QuartzClockHandle", "IsClockRunning");
|
|
|
|
Params::UQuartzClockHandle_IsClockRunning_Params Parms{};
|
|
|
|
Parms.WorldContextObject = WorldContextObject;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function AudioMixer.QuartzClockHandle.GetTicksPerSecond
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
float UQuartzClockHandle::GetTicksPerSecond(class UObject* WorldContextObject)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("QuartzClockHandle", "GetTicksPerSecond");
|
|
|
|
Params::UQuartzClockHandle_GetTicksPerSecond_Params Parms{};
|
|
|
|
Parms.WorldContextObject = WorldContextObject;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function AudioMixer.QuartzClockHandle.GetThirtySecondNotesPerMinute
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
float UQuartzClockHandle::GetThirtySecondNotesPerMinute(class UObject* WorldContextObject)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("QuartzClockHandle", "GetThirtySecondNotesPerMinute");
|
|
|
|
Params::UQuartzClockHandle_GetThirtySecondNotesPerMinute_Params Parms{};
|
|
|
|
Parms.WorldContextObject = WorldContextObject;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function AudioMixer.QuartzClockHandle.GetSecondsPerTick
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
float UQuartzClockHandle::GetSecondsPerTick(class UObject* WorldContextObject)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("QuartzClockHandle", "GetSecondsPerTick");
|
|
|
|
Params::UQuartzClockHandle_GetSecondsPerTick_Params Parms{};
|
|
|
|
Parms.WorldContextObject = WorldContextObject;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function AudioMixer.QuartzClockHandle.GetMillisecondsPerTick
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
float UQuartzClockHandle::GetMillisecondsPerTick(class UObject* WorldContextObject)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("QuartzClockHandle", "GetMillisecondsPerTick");
|
|
|
|
Params::UQuartzClockHandle_GetMillisecondsPerTick_Params Parms{};
|
|
|
|
Parms.WorldContextObject = WorldContextObject;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function AudioMixer.QuartzClockHandle.GetEstimatedRunTime
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
float UQuartzClockHandle::GetEstimatedRunTime(class UObject* WorldContextObject)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("QuartzClockHandle", "GetEstimatedRunTime");
|
|
|
|
Params::UQuartzClockHandle_GetEstimatedRunTime_Params Parms{};
|
|
|
|
Parms.WorldContextObject = WorldContextObject;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function AudioMixer.QuartzClockHandle.GetDurationOfQuantizationTypeInSeconds
|
|
// (Final, Native, Public, HasOutParams, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// enum class EQuartzCommandQuantizationQuantizationType (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float Multiplier (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
float UQuartzClockHandle::GetDurationOfQuantizationTypeInSeconds(class UObject* WorldContextObject, enum class EQuartzCommandQuantization& QuantizationType, float Multiplier)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("QuartzClockHandle", "GetDurationOfQuantizationTypeInSeconds");
|
|
|
|
Params::UQuartzClockHandle_GetDurationOfQuantizationTypeInSeconds_Params Parms{};
|
|
|
|
Parms.WorldContextObject = WorldContextObject;
|
|
Parms.QuantizationType = QuantizationType;
|
|
Parms.Multiplier = Multiplier;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function AudioMixer.QuartzClockHandle.GetCurrentTimestamp
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// struct FQuartzTransportTimeStamp ReturnValue (Parm, OutParm, ReturnParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
|
|
struct FQuartzTransportTimeStamp UQuartzClockHandle::GetCurrentTimestamp(class UObject* WorldContextObject)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("QuartzClockHandle", "GetCurrentTimestamp");
|
|
|
|
Params::UQuartzClockHandle_GetCurrentTimestamp_Params Parms{};
|
|
|
|
Parms.WorldContextObject = WorldContextObject;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function AudioMixer.QuartzClockHandle.GetBeatsPerMinute
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
float UQuartzClockHandle::GetBeatsPerMinute(class UObject* WorldContextObject)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("QuartzClockHandle", "GetBeatsPerMinute");
|
|
|
|
Params::UQuartzClockHandle_GetBeatsPerMinute_Params Parms{};
|
|
|
|
Parms.WorldContextObject = WorldContextObject;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Class AudioMixer.QuartzSubsystem
|
|
// (None)
|
|
|
|
class UClass* UQuartzSubsystem::StaticClass()
|
|
{
|
|
static class UClass* Clss = nullptr;
|
|
|
|
if (!Clss)
|
|
Clss = UObject::FindClassFast("QuartzSubsystem");
|
|
|
|
return Clss;
|
|
}
|
|
|
|
|
|
// QuartzSubsystem AudioMixer.Default__QuartzSubsystem
|
|
// (Public, ClassDefaultObject, ArchetypeObject)
|
|
|
|
class UQuartzSubsystem* UQuartzSubsystem::GetDefaultObj()
|
|
{
|
|
static class UQuartzSubsystem* Default = nullptr;
|
|
|
|
if (!Default)
|
|
Default = static_cast<UQuartzSubsystem*>(UQuartzSubsystem::StaticClass()->DefaultObject);
|
|
|
|
return Default;
|
|
}
|
|
|
|
|
|
// Function AudioMixer.QuartzSubsystem.IsQuartzEnabled
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
bool UQuartzSubsystem::IsQuartzEnabled()
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("QuartzSubsystem", "IsQuartzEnabled");
|
|
|
|
Params::UQuartzSubsystem_IsQuartzEnabled_Params Parms{};
|
|
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function AudioMixer.QuartzSubsystem.IsClockRunning
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class FName ClockName (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
bool UQuartzSubsystem::IsClockRunning(class UObject* WorldContextObject, class FName ClockName)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("QuartzSubsystem", "IsClockRunning");
|
|
|
|
Params::UQuartzSubsystem_IsClockRunning_Params Parms{};
|
|
|
|
Parms.WorldContextObject = WorldContextObject;
|
|
Parms.ClockName = ClockName;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function AudioMixer.QuartzSubsystem.GetRoundTripMinLatency
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
float UQuartzSubsystem::GetRoundTripMinLatency(class UObject* WorldContextObject)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("QuartzSubsystem", "GetRoundTripMinLatency");
|
|
|
|
Params::UQuartzSubsystem_GetRoundTripMinLatency_Params Parms{};
|
|
|
|
Parms.WorldContextObject = WorldContextObject;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function AudioMixer.QuartzSubsystem.GetRoundTripMaxLatency
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
float UQuartzSubsystem::GetRoundTripMaxLatency(class UObject* WorldContextObject)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("QuartzSubsystem", "GetRoundTripMaxLatency");
|
|
|
|
Params::UQuartzSubsystem_GetRoundTripMaxLatency_Params Parms{};
|
|
|
|
Parms.WorldContextObject = WorldContextObject;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function AudioMixer.QuartzSubsystem.GetRoundTripAverageLatency
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
float UQuartzSubsystem::GetRoundTripAverageLatency(class UObject* WorldContextObject)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("QuartzSubsystem", "GetRoundTripAverageLatency");
|
|
|
|
Params::UQuartzSubsystem_GetRoundTripAverageLatency_Params Parms{};
|
|
|
|
Parms.WorldContextObject = WorldContextObject;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function AudioMixer.QuartzSubsystem.GetHandleForClock
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class FName ClockName (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class UQuartzClockHandle* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
class UQuartzClockHandle* UQuartzSubsystem::GetHandleForClock(class UObject* WorldContextObject, class FName ClockName)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("QuartzSubsystem", "GetHandleForClock");
|
|
|
|
Params::UQuartzSubsystem_GetHandleForClock_Params Parms{};
|
|
|
|
Parms.WorldContextObject = WorldContextObject;
|
|
Parms.ClockName = ClockName;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function AudioMixer.QuartzSubsystem.GetGameThreadToAudioRenderThreadMinLatency
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
float UQuartzSubsystem::GetGameThreadToAudioRenderThreadMinLatency(class UObject* WorldContextObject)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("QuartzSubsystem", "GetGameThreadToAudioRenderThreadMinLatency");
|
|
|
|
Params::UQuartzSubsystem_GetGameThreadToAudioRenderThreadMinLatency_Params Parms{};
|
|
|
|
Parms.WorldContextObject = WorldContextObject;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function AudioMixer.QuartzSubsystem.GetGameThreadToAudioRenderThreadMaxLatency
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
float UQuartzSubsystem::GetGameThreadToAudioRenderThreadMaxLatency(class UObject* WorldContextObject)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("QuartzSubsystem", "GetGameThreadToAudioRenderThreadMaxLatency");
|
|
|
|
Params::UQuartzSubsystem_GetGameThreadToAudioRenderThreadMaxLatency_Params Parms{};
|
|
|
|
Parms.WorldContextObject = WorldContextObject;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function AudioMixer.QuartzSubsystem.GetGameThreadToAudioRenderThreadAverageLatency
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
float UQuartzSubsystem::GetGameThreadToAudioRenderThreadAverageLatency(class UObject* WorldContextObject)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("QuartzSubsystem", "GetGameThreadToAudioRenderThreadAverageLatency");
|
|
|
|
Params::UQuartzSubsystem_GetGameThreadToAudioRenderThreadAverageLatency_Params Parms{};
|
|
|
|
Parms.WorldContextObject = WorldContextObject;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function AudioMixer.QuartzSubsystem.GetEstimatedClockRunTime
|
|
// (Final, Native, Public, HasOutParams, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class FName InClockName (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
float UQuartzSubsystem::GetEstimatedClockRunTime(class UObject* WorldContextObject, class FName& InClockName)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("QuartzSubsystem", "GetEstimatedClockRunTime");
|
|
|
|
Params::UQuartzSubsystem_GetEstimatedClockRunTime_Params Parms{};
|
|
|
|
Parms.WorldContextObject = WorldContextObject;
|
|
Parms.InClockName = InClockName;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function AudioMixer.QuartzSubsystem.GetDurationOfQuantizationTypeInSeconds
|
|
// (Final, Native, Public, HasOutParams, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class FName ClockName (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// enum class EQuartzCommandQuantizationQuantizationType (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float Multiplier (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
float UQuartzSubsystem::GetDurationOfQuantizationTypeInSeconds(class UObject* WorldContextObject, class FName ClockName, enum class EQuartzCommandQuantization& QuantizationType, float Multiplier)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("QuartzSubsystem", "GetDurationOfQuantizationTypeInSeconds");
|
|
|
|
Params::UQuartzSubsystem_GetDurationOfQuantizationTypeInSeconds_Params Parms{};
|
|
|
|
Parms.WorldContextObject = WorldContextObject;
|
|
Parms.ClockName = ClockName;
|
|
Parms.QuantizationType = QuantizationType;
|
|
Parms.Multiplier = Multiplier;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function AudioMixer.QuartzSubsystem.GetCurrentClockTimestamp
|
|
// (Final, Native, Public, HasOutParams, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class FName InClockName (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// struct FQuartzTransportTimeStamp ReturnValue (Parm, OutParm, ReturnParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
|
|
struct FQuartzTransportTimeStamp UQuartzSubsystem::GetCurrentClockTimestamp(class UObject* WorldContextObject, class FName& InClockName)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("QuartzSubsystem", "GetCurrentClockTimestamp");
|
|
|
|
Params::UQuartzSubsystem_GetCurrentClockTimestamp_Params Parms{};
|
|
|
|
Parms.WorldContextObject = WorldContextObject;
|
|
Parms.InClockName = InClockName;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function AudioMixer.QuartzSubsystem.GetAudioRenderThreadToGameThreadMinLatency
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
float UQuartzSubsystem::GetAudioRenderThreadToGameThreadMinLatency()
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("QuartzSubsystem", "GetAudioRenderThreadToGameThreadMinLatency");
|
|
|
|
Params::UQuartzSubsystem_GetAudioRenderThreadToGameThreadMinLatency_Params Parms{};
|
|
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function AudioMixer.QuartzSubsystem.GetAudioRenderThreadToGameThreadMaxLatency
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
float UQuartzSubsystem::GetAudioRenderThreadToGameThreadMaxLatency()
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("QuartzSubsystem", "GetAudioRenderThreadToGameThreadMaxLatency");
|
|
|
|
Params::UQuartzSubsystem_GetAudioRenderThreadToGameThreadMaxLatency_Params Parms{};
|
|
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function AudioMixer.QuartzSubsystem.GetAudioRenderThreadToGameThreadAverageLatency
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
float UQuartzSubsystem::GetAudioRenderThreadToGameThreadAverageLatency()
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("QuartzSubsystem", "GetAudioRenderThreadToGameThreadAverageLatency");
|
|
|
|
Params::UQuartzSubsystem_GetAudioRenderThreadToGameThreadAverageLatency_Params Parms{};
|
|
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function AudioMixer.QuartzSubsystem.DoesClockExist
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class FName ClockName (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
bool UQuartzSubsystem::DoesClockExist(class UObject* WorldContextObject, class FName ClockName)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("QuartzSubsystem", "DoesClockExist");
|
|
|
|
Params::UQuartzSubsystem_DoesClockExist_Params Parms{};
|
|
|
|
Parms.WorldContextObject = WorldContextObject;
|
|
Parms.ClockName = ClockName;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function AudioMixer.QuartzSubsystem.DeleteClockByName
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class FName ClockName (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UQuartzSubsystem::DeleteClockByName(class UObject* WorldContextObject, class FName ClockName)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("QuartzSubsystem", "DeleteClockByName");
|
|
|
|
Params::UQuartzSubsystem_DeleteClockByName_Params Parms{};
|
|
|
|
Parms.WorldContextObject = WorldContextObject;
|
|
Parms.ClockName = ClockName;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
}
|
|
|
|
|
|
// Function AudioMixer.QuartzSubsystem.DeleteClockByHandle
|
|
// (Final, Native, Public, HasOutParams, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class UQuartzClockHandle* InClockHandle (Parm, OutParm, ZeroConstructor, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UQuartzSubsystem::DeleteClockByHandle(class UObject* WorldContextObject, class UQuartzClockHandle*& InClockHandle)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("QuartzSubsystem", "DeleteClockByHandle");
|
|
|
|
Params::UQuartzSubsystem_DeleteClockByHandle_Params Parms{};
|
|
|
|
Parms.WorldContextObject = WorldContextObject;
|
|
Parms.InClockHandle = InClockHandle;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
}
|
|
|
|
|
|
// Function AudioMixer.QuartzSubsystem.CreateNewClock
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class FName ClockName (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// struct FQuartzClockSettings InSettings (Parm, NativeAccessSpecifierPublic)
|
|
// bool bOverrideSettingsIfClockExists (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// bool bUseAudioEngineClockManager (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class UQuartzClockHandle* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
class UQuartzClockHandle* UQuartzSubsystem::CreateNewClock(class UObject* WorldContextObject, class FName ClockName, const struct FQuartzClockSettings& InSettings, bool bOverrideSettingsIfClockExists, bool bUseAudioEngineClockManager)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("QuartzSubsystem", "CreateNewClock");
|
|
|
|
Params::UQuartzSubsystem_CreateNewClock_Params Parms{};
|
|
|
|
Parms.WorldContextObject = WorldContextObject;
|
|
Parms.ClockName = ClockName;
|
|
Parms.InSettings = InSettings;
|
|
Parms.bOverrideSettingsIfClockExists = bOverrideSettingsIfClockExists;
|
|
Parms.bUseAudioEngineClockManager = bUseAudioEngineClockManager;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|