5762 lines
188 KiB
C++
5762 lines
188 KiB
C++
#pragma once
|
|
|
|
/*
|
|
* SDK generated by Dumper-7
|
|
*
|
|
* https://github.com/Encryqed/Dumper-7
|
|
*/
|
|
|
|
// Package: Synthesis
|
|
|
|
#include "Basic.hpp"
|
|
|
|
#include "Synthesis_classes.hpp"
|
|
#include "Synthesis_parameters.hpp"
|
|
|
|
|
|
SDK_NAMESPACE_START
|
|
|
|
// Function Synthesis.ModularSynthLibrary.AddModularSynthPresetToBankAsset
|
|
// (Final, Native, Static, Private, HasOutParams, BlueprintCallable)
|
|
// Parameters:
|
|
// class UModularSynthPresetBank* InBank (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// const struct FModularSynthPreset& Preset (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
|
|
// const class FString& PresetName (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UModularSynthLibrary::AddModularSynthPresetToBankAsset(class UModularSynthPresetBank* InBank, const struct FModularSynthPreset& Preset, const class FString& PresetName)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = StaticClass()->GetFunction("ModularSynthLibrary", "AddModularSynthPresetToBankAsset");
|
|
|
|
Params::ModularSynthLibrary_AddModularSynthPresetToBankAsset Parms{};
|
|
|
|
Parms.InBank = InBank;
|
|
Parms.Preset = std::move(Preset);
|
|
Parms.PresetName = std::move(PresetName);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
GetDefaultObj()->ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.ModularSynthComponent.CreatePatch
|
|
// (Final, Native, Public, HasOutParams, BlueprintCallable)
|
|
// Parameters:
|
|
// const ESynth1PatchSource PatchSource (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// const TArray<struct FSynth1PatchCable>& PatchCables (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
|
|
// const bool bEnableByDefault (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// struct FPatchId ReturnValue (Parm, OutParm, ReturnParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
|
|
struct FPatchId UModularSynthComponent::CreatePatch(const ESynth1PatchSource PatchSource, const TArray<struct FSynth1PatchCable>& PatchCables, const bool bEnableByDefault)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("ModularSynthComponent", "CreatePatch");
|
|
|
|
Params::ModularSynthComponent_CreatePatch Parms{};
|
|
|
|
Parms.PatchSource = PatchSource;
|
|
Parms.PatchCables = std::move(PatchCables);
|
|
Parms.bEnableByDefault = bEnableByDefault;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Synthesis.ModularSynthComponent.NoteOff
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// const float Note (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// const bool bAllNotesOff (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// const bool bKillAllNotes (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UModularSynthComponent::NoteOff(const float Note, const bool bAllNotesOff, const bool bKillAllNotes)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("ModularSynthComponent", "NoteOff");
|
|
|
|
Params::ModularSynthComponent_NoteOff Parms{};
|
|
|
|
Parms.Note = Note;
|
|
Parms.bAllNotesOff = bAllNotesOff;
|
|
Parms.bKillAllNotes = bKillAllNotes;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.ModularSynthComponent.NoteOn
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// const float Note (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// const int32 Velocity (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// const float Duration (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UModularSynthComponent::NoteOn(const float Note, const int32 Velocity, const float Duration)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("ModularSynthComponent", "NoteOn");
|
|
|
|
Params::ModularSynthComponent_NoteOn Parms{};
|
|
|
|
Parms.Note = Note;
|
|
Parms.Velocity = Velocity;
|
|
Parms.Duration = Duration;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.ModularSynthComponent.SetAttackTime
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float AttackTimeMsec (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UModularSynthComponent::SetAttackTime(float AttackTimeMsec)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("ModularSynthComponent", "SetAttackTime");
|
|
|
|
Params::ModularSynthComponent_SetAttackTime Parms{};
|
|
|
|
Parms.AttackTimeMsec = AttackTimeMsec;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.ModularSynthComponent.SetChorusDepth
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float Depth (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UModularSynthComponent::SetChorusDepth(float Depth)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("ModularSynthComponent", "SetChorusDepth");
|
|
|
|
Params::ModularSynthComponent_SetChorusDepth Parms{};
|
|
|
|
Parms.Depth = Depth;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.ModularSynthComponent.SetChorusEnabled
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool EnableChorus (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UModularSynthComponent::SetChorusEnabled(bool EnableChorus)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("ModularSynthComponent", "SetChorusEnabled");
|
|
|
|
Params::ModularSynthComponent_SetChorusEnabled Parms{};
|
|
|
|
Parms.EnableChorus = EnableChorus;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.ModularSynthComponent.SetChorusFeedback
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float Feedback (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UModularSynthComponent::SetChorusFeedback(float Feedback)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("ModularSynthComponent", "SetChorusFeedback");
|
|
|
|
Params::ModularSynthComponent_SetChorusFeedback Parms{};
|
|
|
|
Parms.Feedback = Feedback;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.ModularSynthComponent.SetChorusFrequency
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float Frequency (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UModularSynthComponent::SetChorusFrequency(float Frequency)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("ModularSynthComponent", "SetChorusFrequency");
|
|
|
|
Params::ModularSynthComponent_SetChorusFrequency Parms{};
|
|
|
|
Parms.Frequency = Frequency;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.ModularSynthComponent.SetDecayTime
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float DecayTimeMsec (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UModularSynthComponent::SetDecayTime(float DecayTimeMsec)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("ModularSynthComponent", "SetDecayTime");
|
|
|
|
Params::ModularSynthComponent_SetDecayTime Parms{};
|
|
|
|
Parms.DecayTimeMsec = DecayTimeMsec;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.ModularSynthComponent.SetEnableLegato
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool LegatoEnabled (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UModularSynthComponent::SetEnableLegato(bool LegatoEnabled)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("ModularSynthComponent", "SetEnableLegato");
|
|
|
|
Params::ModularSynthComponent_SetEnableLegato Parms{};
|
|
|
|
Parms.LegatoEnabled = LegatoEnabled;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.ModularSynthComponent.SetEnablePatch
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// const struct FPatchId& PatchId (ConstParm, Parm, NoDestructor, NativeAccessSpecifierPublic)
|
|
// const bool bIsEnabled (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
bool UModularSynthComponent::SetEnablePatch(const struct FPatchId& PatchId, const bool bIsEnabled)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("ModularSynthComponent", "SetEnablePatch");
|
|
|
|
Params::ModularSynthComponent_SetEnablePatch Parms{};
|
|
|
|
Parms.PatchId = std::move(PatchId);
|
|
Parms.bIsEnabled = bIsEnabled;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Synthesis.ModularSynthComponent.SetEnablePolyphony
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bEnablePolyphony (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UModularSynthComponent::SetEnablePolyphony(bool bEnablePolyphony)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("ModularSynthComponent", "SetEnablePolyphony");
|
|
|
|
Params::ModularSynthComponent_SetEnablePolyphony Parms{};
|
|
|
|
Parms.bEnablePolyphony = bEnablePolyphony;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.ModularSynthComponent.SetEnableRetrigger
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool RetriggerEnabled (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UModularSynthComponent::SetEnableRetrigger(bool RetriggerEnabled)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("ModularSynthComponent", "SetEnableRetrigger");
|
|
|
|
Params::ModularSynthComponent_SetEnableRetrigger Parms{};
|
|
|
|
Parms.RetriggerEnabled = RetriggerEnabled;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.ModularSynthComponent.SetEnableUnison
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool EnableUnison (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UModularSynthComponent::SetEnableUnison(bool EnableUnison)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("ModularSynthComponent", "SetEnableUnison");
|
|
|
|
Params::ModularSynthComponent_SetEnableUnison Parms{};
|
|
|
|
Parms.EnableUnison = EnableUnison;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.ModularSynthComponent.SetFilterAlgorithm
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// ESynthFilterAlgorithm FilterAlgorithm (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UModularSynthComponent::SetFilterAlgorithm(ESynthFilterAlgorithm FilterAlgorithm)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("ModularSynthComponent", "SetFilterAlgorithm");
|
|
|
|
Params::ModularSynthComponent_SetFilterAlgorithm Parms{};
|
|
|
|
Parms.FilterAlgorithm = FilterAlgorithm;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.ModularSynthComponent.SetFilterFrequency
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float FilterFrequencyHz (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UModularSynthComponent::SetFilterFrequency(float FilterFrequencyHz)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("ModularSynthComponent", "SetFilterFrequency");
|
|
|
|
Params::ModularSynthComponent_SetFilterFrequency Parms{};
|
|
|
|
Parms.FilterFrequencyHz = FilterFrequencyHz;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.ModularSynthComponent.SetFilterFrequencyMod
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float FilterFrequencyHz (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UModularSynthComponent::SetFilterFrequencyMod(float FilterFrequencyHz)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("ModularSynthComponent", "SetFilterFrequencyMod");
|
|
|
|
Params::ModularSynthComponent_SetFilterFrequencyMod Parms{};
|
|
|
|
Parms.FilterFrequencyHz = FilterFrequencyHz;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.ModularSynthComponent.SetFilterQ
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float FilterQ (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UModularSynthComponent::SetFilterQ(float FilterQ)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("ModularSynthComponent", "SetFilterQ");
|
|
|
|
Params::ModularSynthComponent_SetFilterQ Parms{};
|
|
|
|
Parms.FilterQ = FilterQ;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.ModularSynthComponent.SetFilterQMod
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float FilterQ (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UModularSynthComponent::SetFilterQMod(float FilterQ)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("ModularSynthComponent", "SetFilterQMod");
|
|
|
|
Params::ModularSynthComponent_SetFilterQMod Parms{};
|
|
|
|
Parms.FilterQ = FilterQ;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.ModularSynthComponent.SetFilterType
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// ESynthFilterType FilterType (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UModularSynthComponent::SetFilterType(ESynthFilterType FilterType)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("ModularSynthComponent", "SetFilterType");
|
|
|
|
Params::ModularSynthComponent_SetFilterType Parms{};
|
|
|
|
Parms.FilterType = FilterType;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.ModularSynthComponent.SetGainDb
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float GainDb (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UModularSynthComponent::SetGainDb(float GainDb)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("ModularSynthComponent", "SetGainDb");
|
|
|
|
Params::ModularSynthComponent_SetGainDb Parms{};
|
|
|
|
Parms.GainDb = GainDb;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.ModularSynthComponent.SetLFOFrequency
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// int32 LFOIndex (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float FrequencyHz (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UModularSynthComponent::SetLFOFrequency(int32 LFOIndex, float FrequencyHz)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("ModularSynthComponent", "SetLFOFrequency");
|
|
|
|
Params::ModularSynthComponent_SetLFOFrequency Parms{};
|
|
|
|
Parms.LFOIndex = LFOIndex;
|
|
Parms.FrequencyHz = FrequencyHz;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.ModularSynthComponent.SetLFOFrequencyMod
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// int32 LFOIndex (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float FrequencyModHz (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UModularSynthComponent::SetLFOFrequencyMod(int32 LFOIndex, float FrequencyModHz)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("ModularSynthComponent", "SetLFOFrequencyMod");
|
|
|
|
Params::ModularSynthComponent_SetLFOFrequencyMod Parms{};
|
|
|
|
Parms.LFOIndex = LFOIndex;
|
|
Parms.FrequencyModHz = FrequencyModHz;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.ModularSynthComponent.SetLFOGain
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// int32 LFOIndex (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float Gain (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UModularSynthComponent::SetLFOGain(int32 LFOIndex, float Gain)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("ModularSynthComponent", "SetLFOGain");
|
|
|
|
Params::ModularSynthComponent_SetLFOGain Parms{};
|
|
|
|
Parms.LFOIndex = LFOIndex;
|
|
Parms.Gain = Gain;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.ModularSynthComponent.SetLFOGainMod
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// int32 LFOIndex (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float GainMod (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UModularSynthComponent::SetLFOGainMod(int32 LFOIndex, float GainMod)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("ModularSynthComponent", "SetLFOGainMod");
|
|
|
|
Params::ModularSynthComponent_SetLFOGainMod Parms{};
|
|
|
|
Parms.LFOIndex = LFOIndex;
|
|
Parms.GainMod = GainMod;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.ModularSynthComponent.SetLFOMode
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// int32 LFOIndex (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// ESynthLFOMode LFOMode (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UModularSynthComponent::SetLFOMode(int32 LFOIndex, ESynthLFOMode LFOMode)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("ModularSynthComponent", "SetLFOMode");
|
|
|
|
Params::ModularSynthComponent_SetLFOMode Parms{};
|
|
|
|
Parms.LFOIndex = LFOIndex;
|
|
Parms.LFOMode = LFOMode;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.ModularSynthComponent.SetLFOPatch
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// int32 LFOIndex (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// ESynthLFOPatchType LFOPatchType (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UModularSynthComponent::SetLFOPatch(int32 LFOIndex, ESynthLFOPatchType LFOPatchType)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("ModularSynthComponent", "SetLFOPatch");
|
|
|
|
Params::ModularSynthComponent_SetLFOPatch Parms{};
|
|
|
|
Parms.LFOIndex = LFOIndex;
|
|
Parms.LFOPatchType = LFOPatchType;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.ModularSynthComponent.SetLFOType
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// int32 LFOIndex (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// ESynthLFOType LFOType (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UModularSynthComponent::SetLFOType(int32 LFOIndex, ESynthLFOType LFOType)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("ModularSynthComponent", "SetLFOType");
|
|
|
|
Params::ModularSynthComponent_SetLFOType Parms{};
|
|
|
|
Parms.LFOIndex = LFOIndex;
|
|
Parms.LFOType = LFOType;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.ModularSynthComponent.SetModEnvAttackTime
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// const float AttackTimeMsec (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UModularSynthComponent::SetModEnvAttackTime(const float AttackTimeMsec)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("ModularSynthComponent", "SetModEnvAttackTime");
|
|
|
|
Params::ModularSynthComponent_SetModEnvAttackTime Parms{};
|
|
|
|
Parms.AttackTimeMsec = AttackTimeMsec;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.ModularSynthComponent.SetModEnvBiasInvert
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// const bool bInvert (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UModularSynthComponent::SetModEnvBiasInvert(const bool bInvert)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("ModularSynthComponent", "SetModEnvBiasInvert");
|
|
|
|
Params::ModularSynthComponent_SetModEnvBiasInvert Parms{};
|
|
|
|
Parms.bInvert = bInvert;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.ModularSynthComponent.SetModEnvBiasPatch
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// const ESynthModEnvBiasPatch InPatchType (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UModularSynthComponent::SetModEnvBiasPatch(const ESynthModEnvBiasPatch InPatchType)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("ModularSynthComponent", "SetModEnvBiasPatch");
|
|
|
|
Params::ModularSynthComponent_SetModEnvBiasPatch Parms{};
|
|
|
|
Parms.InPatchType = InPatchType;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.ModularSynthComponent.SetModEnvDecayTime
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// const float DecayTimeMsec (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UModularSynthComponent::SetModEnvDecayTime(const float DecayTimeMsec)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("ModularSynthComponent", "SetModEnvDecayTime");
|
|
|
|
Params::ModularSynthComponent_SetModEnvDecayTime Parms{};
|
|
|
|
Parms.DecayTimeMsec = DecayTimeMsec;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.ModularSynthComponent.SetModEnvDepth
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// const float Depth (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UModularSynthComponent::SetModEnvDepth(const float Depth)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("ModularSynthComponent", "SetModEnvDepth");
|
|
|
|
Params::ModularSynthComponent_SetModEnvDepth Parms{};
|
|
|
|
Parms.Depth = Depth;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.ModularSynthComponent.SetModEnvInvert
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// const bool bInvert (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UModularSynthComponent::SetModEnvInvert(const bool bInvert)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("ModularSynthComponent", "SetModEnvInvert");
|
|
|
|
Params::ModularSynthComponent_SetModEnvInvert Parms{};
|
|
|
|
Parms.bInvert = bInvert;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.ModularSynthComponent.SetModEnvPatch
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// const ESynthModEnvPatch InPatchType (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UModularSynthComponent::SetModEnvPatch(const ESynthModEnvPatch InPatchType)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("ModularSynthComponent", "SetModEnvPatch");
|
|
|
|
Params::ModularSynthComponent_SetModEnvPatch Parms{};
|
|
|
|
Parms.InPatchType = InPatchType;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.ModularSynthComponent.SetModEnvReleaseTime
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// const float Release (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UModularSynthComponent::SetModEnvReleaseTime(const float Release)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("ModularSynthComponent", "SetModEnvReleaseTime");
|
|
|
|
Params::ModularSynthComponent_SetModEnvReleaseTime Parms{};
|
|
|
|
Parms.Release = Release;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.ModularSynthComponent.SetModEnvSustainGain
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// const float SustainGain (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UModularSynthComponent::SetModEnvSustainGain(const float SustainGain)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("ModularSynthComponent", "SetModEnvSustainGain");
|
|
|
|
Params::ModularSynthComponent_SetModEnvSustainGain Parms{};
|
|
|
|
Parms.SustainGain = SustainGain;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.ModularSynthComponent.SetOscCents
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// int32 OscIndex (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float Cents (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UModularSynthComponent::SetOscCents(int32 OscIndex, float Cents)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("ModularSynthComponent", "SetOscCents");
|
|
|
|
Params::ModularSynthComponent_SetOscCents Parms{};
|
|
|
|
Parms.OscIndex = OscIndex;
|
|
Parms.Cents = Cents;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.ModularSynthComponent.SetOscFrequencyMod
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// int32 OscIndex (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float OscFreqMod (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UModularSynthComponent::SetOscFrequencyMod(int32 OscIndex, float OscFreqMod)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("ModularSynthComponent", "SetOscFrequencyMod");
|
|
|
|
Params::ModularSynthComponent_SetOscFrequencyMod Parms{};
|
|
|
|
Parms.OscIndex = OscIndex;
|
|
Parms.OscFreqMod = OscFreqMod;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.ModularSynthComponent.SetOscGain
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// int32 OscIndex (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float OscGain (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UModularSynthComponent::SetOscGain(int32 OscIndex, float OscGain)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("ModularSynthComponent", "SetOscGain");
|
|
|
|
Params::ModularSynthComponent_SetOscGain Parms{};
|
|
|
|
Parms.OscIndex = OscIndex;
|
|
Parms.OscGain = OscGain;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.ModularSynthComponent.SetOscGainMod
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// int32 OscIndex (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float OscGainMod (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UModularSynthComponent::SetOscGainMod(int32 OscIndex, float OscGainMod)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("ModularSynthComponent", "SetOscGainMod");
|
|
|
|
Params::ModularSynthComponent_SetOscGainMod Parms{};
|
|
|
|
Parms.OscIndex = OscIndex;
|
|
Parms.OscGainMod = OscGainMod;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.ModularSynthComponent.SetOscOctave
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// int32 OscIndex (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float Octave (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UModularSynthComponent::SetOscOctave(int32 OscIndex, float Octave)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("ModularSynthComponent", "SetOscOctave");
|
|
|
|
Params::ModularSynthComponent_SetOscOctave Parms{};
|
|
|
|
Parms.OscIndex = OscIndex;
|
|
Parms.Octave = Octave;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.ModularSynthComponent.SetOscPulsewidth
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// int32 OscIndex (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float Pulsewidth (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UModularSynthComponent::SetOscPulsewidth(int32 OscIndex, float Pulsewidth)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("ModularSynthComponent", "SetOscPulsewidth");
|
|
|
|
Params::ModularSynthComponent_SetOscPulsewidth Parms{};
|
|
|
|
Parms.OscIndex = OscIndex;
|
|
Parms.Pulsewidth = Pulsewidth;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.ModularSynthComponent.SetOscSemitones
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// int32 OscIndex (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float Semitones (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UModularSynthComponent::SetOscSemitones(int32 OscIndex, float Semitones)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("ModularSynthComponent", "SetOscSemitones");
|
|
|
|
Params::ModularSynthComponent_SetOscSemitones Parms{};
|
|
|
|
Parms.OscIndex = OscIndex;
|
|
Parms.Semitones = Semitones;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.ModularSynthComponent.SetOscSync
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// const bool bIsSynced (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UModularSynthComponent::SetOscSync(const bool bIsSynced)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("ModularSynthComponent", "SetOscSync");
|
|
|
|
Params::ModularSynthComponent_SetOscSync Parms{};
|
|
|
|
Parms.bIsSynced = bIsSynced;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.ModularSynthComponent.SetOscType
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// int32 OscIndex (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// ESynth1OscType OscType (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UModularSynthComponent::SetOscType(int32 OscIndex, ESynth1OscType OscType)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("ModularSynthComponent", "SetOscType");
|
|
|
|
Params::ModularSynthComponent_SetOscType Parms{};
|
|
|
|
Parms.OscIndex = OscIndex;
|
|
Parms.OscType = OscType;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.ModularSynthComponent.SetPan
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float Pan (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UModularSynthComponent::SetPan(float Pan)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("ModularSynthComponent", "SetPan");
|
|
|
|
Params::ModularSynthComponent_SetPan Parms{};
|
|
|
|
Parms.Pan = Pan;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.ModularSynthComponent.SetPitchBend
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float PitchBend (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UModularSynthComponent::SetPitchBend(float PitchBend)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("ModularSynthComponent", "SetPitchBend");
|
|
|
|
Params::ModularSynthComponent_SetPitchBend Parms{};
|
|
|
|
Parms.PitchBend = PitchBend;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.ModularSynthComponent.SetPortamento
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float Portamento (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UModularSynthComponent::SetPortamento(float Portamento)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("ModularSynthComponent", "SetPortamento");
|
|
|
|
Params::ModularSynthComponent_SetPortamento Parms{};
|
|
|
|
Parms.Portamento = Portamento;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.ModularSynthComponent.SetReleaseTime
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float ReleaseTimeMsec (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UModularSynthComponent::SetReleaseTime(float ReleaseTimeMsec)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("ModularSynthComponent", "SetReleaseTime");
|
|
|
|
Params::ModularSynthComponent_SetReleaseTime Parms{};
|
|
|
|
Parms.ReleaseTimeMsec = ReleaseTimeMsec;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.ModularSynthComponent.SetSpread
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float Spread (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UModularSynthComponent::SetSpread(float Spread)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("ModularSynthComponent", "SetSpread");
|
|
|
|
Params::ModularSynthComponent_SetSpread Parms{};
|
|
|
|
Parms.Spread = Spread;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.ModularSynthComponent.SetStereoDelayFeedback
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float DelayFeedback (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UModularSynthComponent::SetStereoDelayFeedback(float DelayFeedback)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("ModularSynthComponent", "SetStereoDelayFeedback");
|
|
|
|
Params::ModularSynthComponent_SetStereoDelayFeedback Parms{};
|
|
|
|
Parms.DelayFeedback = DelayFeedback;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.ModularSynthComponent.SetStereoDelayIsEnabled
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool StereoDelayEnabled (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UModularSynthComponent::SetStereoDelayIsEnabled(bool StereoDelayEnabled)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("ModularSynthComponent", "SetStereoDelayIsEnabled");
|
|
|
|
Params::ModularSynthComponent_SetStereoDelayIsEnabled Parms{};
|
|
|
|
Parms.StereoDelayEnabled = StereoDelayEnabled;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.ModularSynthComponent.SetStereoDelayMode
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// ESynthStereoDelayMode StereoDelayMode (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UModularSynthComponent::SetStereoDelayMode(ESynthStereoDelayMode StereoDelayMode)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("ModularSynthComponent", "SetStereoDelayMode");
|
|
|
|
Params::ModularSynthComponent_SetStereoDelayMode Parms{};
|
|
|
|
Parms.StereoDelayMode = StereoDelayMode;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.ModularSynthComponent.SetStereoDelayRatio
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float DelayRatio (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UModularSynthComponent::SetStereoDelayRatio(float DelayRatio)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("ModularSynthComponent", "SetStereoDelayRatio");
|
|
|
|
Params::ModularSynthComponent_SetStereoDelayRatio Parms{};
|
|
|
|
Parms.DelayRatio = DelayRatio;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.ModularSynthComponent.SetStereoDelayTime
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float DelayTimeMsec (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UModularSynthComponent::SetStereoDelayTime(float DelayTimeMsec)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("ModularSynthComponent", "SetStereoDelayTime");
|
|
|
|
Params::ModularSynthComponent_SetStereoDelayTime Parms{};
|
|
|
|
Parms.DelayTimeMsec = DelayTimeMsec;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.ModularSynthComponent.SetStereoDelayWetlevel
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float DelayWetlevel (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UModularSynthComponent::SetStereoDelayWetlevel(float DelayWetlevel)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("ModularSynthComponent", "SetStereoDelayWetlevel");
|
|
|
|
Params::ModularSynthComponent_SetStereoDelayWetlevel Parms{};
|
|
|
|
Parms.DelayWetlevel = DelayWetlevel;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.ModularSynthComponent.SetSustainGain
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float SustainGain (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UModularSynthComponent::SetSustainGain(float SustainGain)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("ModularSynthComponent", "SetSustainGain");
|
|
|
|
Params::ModularSynthComponent_SetSustainGain Parms{};
|
|
|
|
Parms.SustainGain = SustainGain;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.ModularSynthComponent.SetSynthPreset
|
|
// (Final, Native, Public, HasOutParams, BlueprintCallable)
|
|
// Parameters:
|
|
// const struct FModularSynthPreset& SynthPreset (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
|
|
|
|
void UModularSynthComponent::SetSynthPreset(const struct FModularSynthPreset& SynthPreset)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("ModularSynthComponent", "SetSynthPreset");
|
|
|
|
Params::ModularSynthComponent_SetSynthPreset Parms{};
|
|
|
|
Parms.SynthPreset = std::move(SynthPreset);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SourceEffectBitCrusherPreset.SetBitModulator
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// const class USoundModulatorBase* Modulator (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void USourceEffectBitCrusherPreset::SetBitModulator(const class USoundModulatorBase* Modulator)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("SourceEffectBitCrusherPreset", "SetBitModulator");
|
|
|
|
Params::SourceEffectBitCrusherPreset_SetBitModulator Parms{};
|
|
|
|
Parms.Modulator = Modulator;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SourceEffectBitCrusherPreset.SetBitModulators
|
|
// (Final, Native, Public, HasOutParams, BlueprintCallable)
|
|
// Parameters:
|
|
// const TSet<class USoundModulatorBase*>& InModulators (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
|
|
|
|
void USourceEffectBitCrusherPreset::SetBitModulators(const TSet<class USoundModulatorBase*>& InModulators)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("SourceEffectBitCrusherPreset", "SetBitModulators");
|
|
|
|
Params::SourceEffectBitCrusherPreset_SetBitModulators Parms{};
|
|
|
|
Parms.InModulators = std::move(InModulators);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SourceEffectBitCrusherPreset.SetBits
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float Bits (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void USourceEffectBitCrusherPreset::SetBits(float Bits)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("SourceEffectBitCrusherPreset", "SetBits");
|
|
|
|
Params::SourceEffectBitCrusherPreset_SetBits Parms{};
|
|
|
|
Parms.Bits = Bits;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SourceEffectBitCrusherPreset.SetModulationSettings
|
|
// (Final, Native, Public, HasOutParams, BlueprintCallable)
|
|
// Parameters:
|
|
// const struct FSourceEffectBitCrusherSettings&ModulationSettings (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
|
|
|
|
void USourceEffectBitCrusherPreset::SetModulationSettings(const struct FSourceEffectBitCrusherSettings& ModulationSettings)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("SourceEffectBitCrusherPreset", "SetModulationSettings");
|
|
|
|
Params::SourceEffectBitCrusherPreset_SetModulationSettings Parms{};
|
|
|
|
Parms.ModulationSettings = std::move(ModulationSettings);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SourceEffectBitCrusherPreset.SetSampleRate
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float SampleRate (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void USourceEffectBitCrusherPreset::SetSampleRate(float SampleRate)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("SourceEffectBitCrusherPreset", "SetSampleRate");
|
|
|
|
Params::SourceEffectBitCrusherPreset_SetSampleRate Parms{};
|
|
|
|
Parms.SampleRate = SampleRate;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SourceEffectBitCrusherPreset.SetSampleRateModulator
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// const class USoundModulatorBase* Modulator (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void USourceEffectBitCrusherPreset::SetSampleRateModulator(const class USoundModulatorBase* Modulator)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("SourceEffectBitCrusherPreset", "SetSampleRateModulator");
|
|
|
|
Params::SourceEffectBitCrusherPreset_SetSampleRateModulator Parms{};
|
|
|
|
Parms.Modulator = Modulator;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SourceEffectBitCrusherPreset.SetSampleRateModulators
|
|
// (Final, Native, Public, HasOutParams, BlueprintCallable)
|
|
// Parameters:
|
|
// const TSet<class USoundModulatorBase*>& InModulators (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
|
|
|
|
void USourceEffectBitCrusherPreset::SetSampleRateModulators(const TSet<class USoundModulatorBase*>& InModulators)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("SourceEffectBitCrusherPreset", "SetSampleRateModulators");
|
|
|
|
Params::SourceEffectBitCrusherPreset_SetSampleRateModulators Parms{};
|
|
|
|
Parms.InModulators = std::move(InModulators);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SourceEffectBitCrusherPreset.SetSettings
|
|
// (Final, Native, Public, HasOutParams, BlueprintCallable)
|
|
// Parameters:
|
|
// const struct FSourceEffectBitCrusherBaseSettings&Settings_0 (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
|
|
void USourceEffectBitCrusherPreset::SetSettings(const struct FSourceEffectBitCrusherBaseSettings& Settings_0)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("SourceEffectBitCrusherPreset", "SetSettings");
|
|
|
|
Params::SourceEffectBitCrusherPreset_SetSettings Parms{};
|
|
|
|
Parms.Settings_0 = std::move(Settings_0);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SourceEffectChorusPreset.SetDepth
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float Depth (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void USourceEffectChorusPreset::SetDepth(float Depth)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("SourceEffectChorusPreset", "SetDepth");
|
|
|
|
Params::SourceEffectChorusPreset_SetDepth Parms{};
|
|
|
|
Parms.Depth = Depth;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SourceEffectChorusPreset.SetDepthModulator
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// const class USoundModulatorBase* Modulator (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void USourceEffectChorusPreset::SetDepthModulator(const class USoundModulatorBase* Modulator)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("SourceEffectChorusPreset", "SetDepthModulator");
|
|
|
|
Params::SourceEffectChorusPreset_SetDepthModulator Parms{};
|
|
|
|
Parms.Modulator = Modulator;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SourceEffectChorusPreset.SetDepthModulators
|
|
// (Final, Native, Public, HasOutParams, BlueprintCallable)
|
|
// Parameters:
|
|
// const TSet<class USoundModulatorBase*>& Modulators (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
|
|
|
|
void USourceEffectChorusPreset::SetDepthModulators(const TSet<class USoundModulatorBase*>& Modulators)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("SourceEffectChorusPreset", "SetDepthModulators");
|
|
|
|
Params::SourceEffectChorusPreset_SetDepthModulators Parms{};
|
|
|
|
Parms.Modulators = std::move(Modulators);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SourceEffectChorusPreset.SetDry
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float DryAmount (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void USourceEffectChorusPreset::SetDry(float DryAmount)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("SourceEffectChorusPreset", "SetDry");
|
|
|
|
Params::SourceEffectChorusPreset_SetDry Parms{};
|
|
|
|
Parms.DryAmount = DryAmount;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SourceEffectChorusPreset.SetDryModulator
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// const class USoundModulatorBase* Modulator (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void USourceEffectChorusPreset::SetDryModulator(const class USoundModulatorBase* Modulator)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("SourceEffectChorusPreset", "SetDryModulator");
|
|
|
|
Params::SourceEffectChorusPreset_SetDryModulator Parms{};
|
|
|
|
Parms.Modulator = Modulator;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SourceEffectChorusPreset.SetDryModulators
|
|
// (Final, Native, Public, HasOutParams, BlueprintCallable)
|
|
// Parameters:
|
|
// const TSet<class USoundModulatorBase*>& Modulators (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
|
|
|
|
void USourceEffectChorusPreset::SetDryModulators(const TSet<class USoundModulatorBase*>& Modulators)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("SourceEffectChorusPreset", "SetDryModulators");
|
|
|
|
Params::SourceEffectChorusPreset_SetDryModulators Parms{};
|
|
|
|
Parms.Modulators = std::move(Modulators);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SourceEffectChorusPreset.SetFeedback
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float Feedback (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void USourceEffectChorusPreset::SetFeedback(float Feedback)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("SourceEffectChorusPreset", "SetFeedback");
|
|
|
|
Params::SourceEffectChorusPreset_SetFeedback Parms{};
|
|
|
|
Parms.Feedback = Feedback;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SourceEffectChorusPreset.SetFeedbackModulator
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// const class USoundModulatorBase* Modulator (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void USourceEffectChorusPreset::SetFeedbackModulator(const class USoundModulatorBase* Modulator)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("SourceEffectChorusPreset", "SetFeedbackModulator");
|
|
|
|
Params::SourceEffectChorusPreset_SetFeedbackModulator Parms{};
|
|
|
|
Parms.Modulator = Modulator;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SourceEffectChorusPreset.SetFeedbackModulators
|
|
// (Final, Native, Public, HasOutParams, BlueprintCallable)
|
|
// Parameters:
|
|
// const TSet<class USoundModulatorBase*>& Modulators (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
|
|
|
|
void USourceEffectChorusPreset::SetFeedbackModulators(const TSet<class USoundModulatorBase*>& Modulators)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("SourceEffectChorusPreset", "SetFeedbackModulators");
|
|
|
|
Params::SourceEffectChorusPreset_SetFeedbackModulators Parms{};
|
|
|
|
Parms.Modulators = std::move(Modulators);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SourceEffectChorusPreset.SetFrequency
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float Frequency (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void USourceEffectChorusPreset::SetFrequency(float Frequency)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("SourceEffectChorusPreset", "SetFrequency");
|
|
|
|
Params::SourceEffectChorusPreset_SetFrequency Parms{};
|
|
|
|
Parms.Frequency = Frequency;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SourceEffectChorusPreset.SetFrequencyModulator
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// const class USoundModulatorBase* Modulator (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void USourceEffectChorusPreset::SetFrequencyModulator(const class USoundModulatorBase* Modulator)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("SourceEffectChorusPreset", "SetFrequencyModulator");
|
|
|
|
Params::SourceEffectChorusPreset_SetFrequencyModulator Parms{};
|
|
|
|
Parms.Modulator = Modulator;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SourceEffectChorusPreset.SetFrequencyModulators
|
|
// (Final, Native, Public, HasOutParams, BlueprintCallable)
|
|
// Parameters:
|
|
// const TSet<class USoundModulatorBase*>& Modulators (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
|
|
|
|
void USourceEffectChorusPreset::SetFrequencyModulators(const TSet<class USoundModulatorBase*>& Modulators)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("SourceEffectChorusPreset", "SetFrequencyModulators");
|
|
|
|
Params::SourceEffectChorusPreset_SetFrequencyModulators Parms{};
|
|
|
|
Parms.Modulators = std::move(Modulators);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SourceEffectChorusPreset.SetModulationSettings
|
|
// (Final, Native, Public, HasOutParams, BlueprintCallable)
|
|
// Parameters:
|
|
// const struct FSourceEffectChorusSettings&ModulationSettings (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
|
|
|
|
void USourceEffectChorusPreset::SetModulationSettings(const struct FSourceEffectChorusSettings& ModulationSettings)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("SourceEffectChorusPreset", "SetModulationSettings");
|
|
|
|
Params::SourceEffectChorusPreset_SetModulationSettings Parms{};
|
|
|
|
Parms.ModulationSettings = std::move(ModulationSettings);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SourceEffectChorusPreset.SetSettings
|
|
// (Final, Native, Public, HasOutParams, BlueprintCallable)
|
|
// Parameters:
|
|
// const struct FSourceEffectChorusBaseSettings&Settings_0 (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
|
|
void USourceEffectChorusPreset::SetSettings(const struct FSourceEffectChorusBaseSettings& Settings_0)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("SourceEffectChorusPreset", "SetSettings");
|
|
|
|
Params::SourceEffectChorusPreset_SetSettings Parms{};
|
|
|
|
Parms.Settings_0 = std::move(Settings_0);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SourceEffectChorusPreset.SetSpread
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float Spread (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void USourceEffectChorusPreset::SetSpread(float Spread)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("SourceEffectChorusPreset", "SetSpread");
|
|
|
|
Params::SourceEffectChorusPreset_SetSpread Parms{};
|
|
|
|
Parms.Spread = Spread;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SourceEffectChorusPreset.SetSpreadModulator
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// const class USoundModulatorBase* Modulator (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void USourceEffectChorusPreset::SetSpreadModulator(const class USoundModulatorBase* Modulator)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("SourceEffectChorusPreset", "SetSpreadModulator");
|
|
|
|
Params::SourceEffectChorusPreset_SetSpreadModulator Parms{};
|
|
|
|
Parms.Modulator = Modulator;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SourceEffectChorusPreset.SetSpreadModulators
|
|
// (Final, Native, Public, HasOutParams, BlueprintCallable)
|
|
// Parameters:
|
|
// const TSet<class USoundModulatorBase*>& Modulators (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
|
|
|
|
void USourceEffectChorusPreset::SetSpreadModulators(const TSet<class USoundModulatorBase*>& Modulators)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("SourceEffectChorusPreset", "SetSpreadModulators");
|
|
|
|
Params::SourceEffectChorusPreset_SetSpreadModulators Parms{};
|
|
|
|
Parms.Modulators = std::move(Modulators);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SourceEffectChorusPreset.SetWet
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float WetAmount (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void USourceEffectChorusPreset::SetWet(float WetAmount)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("SourceEffectChorusPreset", "SetWet");
|
|
|
|
Params::SourceEffectChorusPreset_SetWet Parms{};
|
|
|
|
Parms.WetAmount = WetAmount;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SourceEffectChorusPreset.SetWetModulator
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// const class USoundModulatorBase* Modulator (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void USourceEffectChorusPreset::SetWetModulator(const class USoundModulatorBase* Modulator)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("SourceEffectChorusPreset", "SetWetModulator");
|
|
|
|
Params::SourceEffectChorusPreset_SetWetModulator Parms{};
|
|
|
|
Parms.Modulator = Modulator;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SourceEffectChorusPreset.SetWetModulators
|
|
// (Final, Native, Public, HasOutParams, BlueprintCallable)
|
|
// Parameters:
|
|
// const TSet<class USoundModulatorBase*>& Modulators (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
|
|
|
|
void USourceEffectChorusPreset::SetWetModulators(const TSet<class USoundModulatorBase*>& Modulators)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("SourceEffectChorusPreset", "SetWetModulators");
|
|
|
|
Params::SourceEffectChorusPreset_SetWetModulators Parms{};
|
|
|
|
Parms.Modulators = std::move(Modulators);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SourceEffectConvolutionReverbPreset.SetImpulseResponse
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UAudioImpulseResponse* InImpulseResponse (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void USourceEffectConvolutionReverbPreset::SetImpulseResponse(class UAudioImpulseResponse* InImpulseResponse)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("SourceEffectConvolutionReverbPreset", "SetImpulseResponse");
|
|
|
|
Params::SourceEffectConvolutionReverbPreset_SetImpulseResponse Parms{};
|
|
|
|
Parms.InImpulseResponse = InImpulseResponse;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SourceEffectConvolutionReverbPreset.SetSettings
|
|
// (Final, Native, Public, HasOutParams, BlueprintCallable)
|
|
// Parameters:
|
|
// const struct FSourceEffectConvolutionReverbSettings&InSettings (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
|
|
void USourceEffectConvolutionReverbPreset::SetSettings(const struct FSourceEffectConvolutionReverbSettings& InSettings)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("SourceEffectConvolutionReverbPreset", "SetSettings");
|
|
|
|
Params::SourceEffectConvolutionReverbPreset_SetSettings Parms{};
|
|
|
|
Parms.InSettings = std::move(InSettings);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SourceEffectDynamicsProcessorPreset.SetSettings
|
|
// (Final, Native, Public, HasOutParams, BlueprintCallable)
|
|
// Parameters:
|
|
// const struct FSourceEffectDynamicsProcessorSettings&InSettings (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
|
|
void USourceEffectDynamicsProcessorPreset::SetSettings(const struct FSourceEffectDynamicsProcessorSettings& InSettings)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("SourceEffectDynamicsProcessorPreset", "SetSettings");
|
|
|
|
Params::SourceEffectDynamicsProcessorPreset_SetSettings Parms{};
|
|
|
|
Parms.InSettings = std::move(InSettings);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SourceEffectEnvelopeFollowerPreset.RegisterEnvelopeFollowerListener
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UEnvelopeFollowerListener* EnvelopeFollowerListener (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void USourceEffectEnvelopeFollowerPreset::RegisterEnvelopeFollowerListener(class UEnvelopeFollowerListener* EnvelopeFollowerListener)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("SourceEffectEnvelopeFollowerPreset", "RegisterEnvelopeFollowerListener");
|
|
|
|
Params::SourceEffectEnvelopeFollowerPreset_RegisterEnvelopeFollowerListener Parms{};
|
|
|
|
Parms.EnvelopeFollowerListener = EnvelopeFollowerListener;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SourceEffectEnvelopeFollowerPreset.SetSettings
|
|
// (Final, Native, Public, HasOutParams, BlueprintCallable)
|
|
// Parameters:
|
|
// const struct FSourceEffectEnvelopeFollowerSettings&InSettings (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
|
|
void USourceEffectEnvelopeFollowerPreset::SetSettings(const struct FSourceEffectEnvelopeFollowerSettings& InSettings)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("SourceEffectEnvelopeFollowerPreset", "SetSettings");
|
|
|
|
Params::SourceEffectEnvelopeFollowerPreset_SetSettings Parms{};
|
|
|
|
Parms.InSettings = std::move(InSettings);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SourceEffectEnvelopeFollowerPreset.UnregisterEnvelopeFollowerListener
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UEnvelopeFollowerListener* EnvelopeFollowerListener (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void USourceEffectEnvelopeFollowerPreset::UnregisterEnvelopeFollowerListener(class UEnvelopeFollowerListener* EnvelopeFollowerListener)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("SourceEffectEnvelopeFollowerPreset", "UnregisterEnvelopeFollowerListener");
|
|
|
|
Params::SourceEffectEnvelopeFollowerPreset_UnregisterEnvelopeFollowerListener Parms{};
|
|
|
|
Parms.EnvelopeFollowerListener = EnvelopeFollowerListener;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SourceEffectEQPreset.SetSettings
|
|
// (Final, Native, Public, HasOutParams, BlueprintCallable)
|
|
// Parameters:
|
|
// const struct FSourceEffectEQSettings& InSettings (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
|
|
|
|
void USourceEffectEQPreset::SetSettings(const struct FSourceEffectEQSettings& InSettings)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("SourceEffectEQPreset", "SetSettings");
|
|
|
|
Params::SourceEffectEQPreset_SetSettings Parms{};
|
|
|
|
Parms.InSettings = std::move(InSettings);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SourceEffectFilterPreset.SetSettings
|
|
// (Final, Native, Public, HasOutParams, BlueprintCallable)
|
|
// Parameters:
|
|
// const struct FSourceEffectFilterSettings&InSettings (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
|
|
|
|
void USourceEffectFilterPreset::SetSettings(const struct FSourceEffectFilterSettings& InSettings)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("SourceEffectFilterPreset", "SetSettings");
|
|
|
|
Params::SourceEffectFilterPreset_SetSettings Parms{};
|
|
|
|
Parms.InSettings = std::move(InSettings);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SourceEffectFoldbackDistortionPreset.SetSettings
|
|
// (Final, Native, Public, HasOutParams, BlueprintCallable)
|
|
// Parameters:
|
|
// const struct FSourceEffectFoldbackDistortionSettings&InSettings (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
|
|
void USourceEffectFoldbackDistortionPreset::SetSettings(const struct FSourceEffectFoldbackDistortionSettings& InSettings)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("SourceEffectFoldbackDistortionPreset", "SetSettings");
|
|
|
|
Params::SourceEffectFoldbackDistortionPreset_SetSettings Parms{};
|
|
|
|
Parms.InSettings = std::move(InSettings);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SourceEffectMidSideSpreaderPreset.SetSettings
|
|
// (Final, Native, Public, HasOutParams, BlueprintCallable)
|
|
// Parameters:
|
|
// const struct FSourceEffectMidSideSpreaderSettings&InSettings (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
|
|
void USourceEffectMidSideSpreaderPreset::SetSettings(const struct FSourceEffectMidSideSpreaderSettings& InSettings)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("SourceEffectMidSideSpreaderPreset", "SetSettings");
|
|
|
|
Params::SourceEffectMidSideSpreaderPreset_SetSettings Parms{};
|
|
|
|
Parms.InSettings = std::move(InSettings);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SourceEffectMotionFilterPreset.SetSettings
|
|
// (Final, Native, Public, HasOutParams, BlueprintCallable)
|
|
// Parameters:
|
|
// const struct FSourceEffectMotionFilterSettings&InSettings (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
|
|
|
|
void USourceEffectMotionFilterPreset::SetSettings(const struct FSourceEffectMotionFilterSettings& InSettings)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("SourceEffectMotionFilterPreset", "SetSettings");
|
|
|
|
Params::SourceEffectMotionFilterPreset_SetSettings Parms{};
|
|
|
|
Parms.InSettings = std::move(InSettings);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SourceEffectPannerPreset.SetSettings
|
|
// (Final, Native, Public, HasOutParams, BlueprintCallable)
|
|
// Parameters:
|
|
// const struct FSourceEffectPannerSettings&InSettings (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
|
|
void USourceEffectPannerPreset::SetSettings(const struct FSourceEffectPannerSettings& InSettings)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("SourceEffectPannerPreset", "SetSettings");
|
|
|
|
Params::SourceEffectPannerPreset_SetSettings Parms{};
|
|
|
|
Parms.InSettings = std::move(InSettings);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SourceEffectPhaserPreset.SetSettings
|
|
// (Final, Native, Public, HasOutParams, BlueprintCallable)
|
|
// Parameters:
|
|
// const struct FSourceEffectPhaserSettings&InSettings (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
|
|
void USourceEffectPhaserPreset::SetSettings(const struct FSourceEffectPhaserSettings& InSettings)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("SourceEffectPhaserPreset", "SetSettings");
|
|
|
|
Params::SourceEffectPhaserPreset_SetSettings Parms{};
|
|
|
|
Parms.InSettings = std::move(InSettings);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SourceEffectRingModulationPreset.SetSettings
|
|
// (Final, Native, Public, HasOutParams, BlueprintCallable)
|
|
// Parameters:
|
|
// const struct FSourceEffectRingModulationSettings&InSettings (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
|
|
void USourceEffectRingModulationPreset::SetSettings(const struct FSourceEffectRingModulationSettings& InSettings)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("SourceEffectRingModulationPreset", "SetSettings");
|
|
|
|
Params::SourceEffectRingModulationPreset_SetSettings Parms{};
|
|
|
|
Parms.InSettings = std::move(InSettings);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SourceEffectSimpleDelayPreset.SetSettings
|
|
// (Final, Native, Public, HasOutParams, BlueprintCallable)
|
|
// Parameters:
|
|
// const struct FSourceEffectSimpleDelaySettings&InSettings (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
|
|
void USourceEffectSimpleDelayPreset::SetSettings(const struct FSourceEffectSimpleDelaySettings& InSettings)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("SourceEffectSimpleDelayPreset", "SetSettings");
|
|
|
|
Params::SourceEffectSimpleDelayPreset_SetSettings Parms{};
|
|
|
|
Parms.InSettings = std::move(InSettings);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SourceEffectStereoDelayPreset.SetSettings
|
|
// (Final, Native, Public, HasOutParams, BlueprintCallable)
|
|
// Parameters:
|
|
// const struct FSourceEffectStereoDelaySettings&InSettings (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
|
|
void USourceEffectStereoDelayPreset::SetSettings(const struct FSourceEffectStereoDelaySettings& InSettings)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("SourceEffectStereoDelayPreset", "SetSettings");
|
|
|
|
Params::SourceEffectStereoDelayPreset_SetSettings Parms{};
|
|
|
|
Parms.InSettings = std::move(InSettings);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SourceEffectWaveShaperPreset.SetSettings
|
|
// (Final, Native, Public, HasOutParams, BlueprintCallable)
|
|
// Parameters:
|
|
// const struct FSourceEffectWaveShaperSettings&InSettings (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
|
|
void USourceEffectWaveShaperPreset::SetSettings(const struct FSourceEffectWaveShaperSettings& InSettings)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("SourceEffectWaveShaperPreset", "SetSettings");
|
|
|
|
Params::SourceEffectWaveShaperPreset_SetSettings Parms{};
|
|
|
|
Parms.InSettings = std::move(InSettings);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SubmixEffectConvolutionReverbPreset.SetImpulseResponse
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UAudioImpulseResponse* InImpulseResponse (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void USubmixEffectConvolutionReverbPreset::SetImpulseResponse(class UAudioImpulseResponse* InImpulseResponse)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("SubmixEffectConvolutionReverbPreset", "SetImpulseResponse");
|
|
|
|
Params::SubmixEffectConvolutionReverbPreset_SetImpulseResponse Parms{};
|
|
|
|
Parms.InImpulseResponse = InImpulseResponse;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SubmixEffectConvolutionReverbPreset.SetSettings
|
|
// (Final, Native, Public, HasOutParams, BlueprintCallable)
|
|
// Parameters:
|
|
// const struct FSubmixEffectConvolutionReverbSettings&InSettings (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
|
|
void USubmixEffectConvolutionReverbPreset::SetSettings(const struct FSubmixEffectConvolutionReverbSettings& InSettings)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("SubmixEffectConvolutionReverbPreset", "SetSettings");
|
|
|
|
Params::SubmixEffectConvolutionReverbPreset_SetSettings Parms{};
|
|
|
|
Parms.InSettings = std::move(InSettings);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SubmixEffectDelayStatics.SetDelayLength
|
|
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FSubmixEffectDelaySettings& DelaySettings (Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
// float DelayLength (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// struct FSubmixEffectDelaySettings ReturnValue (Parm, OutParm, ReturnParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
|
|
struct FSubmixEffectDelaySettings USubmixEffectDelayStatics::SetDelayLength(struct FSubmixEffectDelaySettings& DelaySettings, float DelayLength)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = StaticClass()->GetFunction("SubmixEffectDelayStatics", "SetDelayLength");
|
|
|
|
Params::SubmixEffectDelayStatics_SetDelayLength Parms{};
|
|
|
|
Parms.DelaySettings = std::move(DelaySettings);
|
|
Parms.DelayLength = DelayLength;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
GetDefaultObj()->ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
DelaySettings = std::move(Parms.DelaySettings);
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SubmixEffectDelayStatics.SetInterpolationTime
|
|
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FSubmixEffectDelaySettings& DelaySettings (Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
// float InterpolationTime (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// struct FSubmixEffectDelaySettings ReturnValue (Parm, OutParm, ReturnParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
|
|
struct FSubmixEffectDelaySettings USubmixEffectDelayStatics::SetInterpolationTime(struct FSubmixEffectDelaySettings& DelaySettings, float InterpolationTime)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = StaticClass()->GetFunction("SubmixEffectDelayStatics", "SetInterpolationTime");
|
|
|
|
Params::SubmixEffectDelayStatics_SetInterpolationTime Parms{};
|
|
|
|
Parms.DelaySettings = std::move(DelaySettings);
|
|
Parms.InterpolationTime = InterpolationTime;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
GetDefaultObj()->ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
DelaySettings = std::move(Parms.DelaySettings);
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SubmixEffectDelayStatics.SetMaximumDelayLength
|
|
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FSubmixEffectDelaySettings& DelaySettings (Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
// float MaximumDelayLength (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// struct FSubmixEffectDelaySettings ReturnValue (Parm, OutParm, ReturnParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
|
|
struct FSubmixEffectDelaySettings USubmixEffectDelayStatics::SetMaximumDelayLength(struct FSubmixEffectDelaySettings& DelaySettings, float MaximumDelayLength)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = StaticClass()->GetFunction("SubmixEffectDelayStatics", "SetMaximumDelayLength");
|
|
|
|
Params::SubmixEffectDelayStatics_SetMaximumDelayLength Parms{};
|
|
|
|
Parms.DelaySettings = std::move(DelaySettings);
|
|
Parms.MaximumDelayLength = MaximumDelayLength;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
GetDefaultObj()->ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
DelaySettings = std::move(Parms.DelaySettings);
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SubmixEffectDelayPreset.SetDefaultSettings
|
|
// (Final, Native, Public, HasOutParams, BlueprintCallable)
|
|
// Parameters:
|
|
// const struct FSubmixEffectDelaySettings&InSettings (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
|
|
void USubmixEffectDelayPreset::SetDefaultSettings(const struct FSubmixEffectDelaySettings& InSettings)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("SubmixEffectDelayPreset", "SetDefaultSettings");
|
|
|
|
Params::SubmixEffectDelayPreset_SetDefaultSettings Parms{};
|
|
|
|
Parms.InSettings = std::move(InSettings);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SubmixEffectDelayPreset.SetDelay
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float Length (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void USubmixEffectDelayPreset::SetDelay(float Length)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("SubmixEffectDelayPreset", "SetDelay");
|
|
|
|
Params::SubmixEffectDelayPreset_SetDelay Parms{};
|
|
|
|
Parms.Length = Length;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SubmixEffectDelayPreset.SetInterpolationTime
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float Time (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void USubmixEffectDelayPreset::SetInterpolationTime(float Time)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("SubmixEffectDelayPreset", "SetInterpolationTime");
|
|
|
|
Params::SubmixEffectDelayPreset_SetInterpolationTime Parms{};
|
|
|
|
Parms.Time = Time;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SubmixEffectDelayPreset.SetSettings
|
|
// (Final, Native, Public, HasOutParams, BlueprintCallable)
|
|
// Parameters:
|
|
// const struct FSubmixEffectDelaySettings&InSettings (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
|
|
void USubmixEffectDelayPreset::SetSettings(const struct FSubmixEffectDelaySettings& InSettings)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("SubmixEffectDelayPreset", "SetSettings");
|
|
|
|
Params::SubmixEffectDelayPreset_SetSettings Parms{};
|
|
|
|
Parms.InSettings = std::move(InSettings);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SubmixEffectDelayPreset.GetMaxDelayInMilliseconds
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
float USubmixEffectDelayPreset::GetMaxDelayInMilliseconds() const
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("SubmixEffectDelayPreset", "GetMaxDelayInMilliseconds");
|
|
|
|
Params::SubmixEffectDelayPreset_GetMaxDelayInMilliseconds Parms{};
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SubmixEffectFilterPreset.SetFilterAlgorithm
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// ESubmixFilterAlgorithm InAlgorithm (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void USubmixEffectFilterPreset::SetFilterAlgorithm(ESubmixFilterAlgorithm InAlgorithm)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("SubmixEffectFilterPreset", "SetFilterAlgorithm");
|
|
|
|
Params::SubmixEffectFilterPreset_SetFilterAlgorithm Parms{};
|
|
|
|
Parms.InAlgorithm = InAlgorithm;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SubmixEffectFilterPreset.SetFilterCutoffFrequency
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float InFrequency (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void USubmixEffectFilterPreset::SetFilterCutoffFrequency(float InFrequency)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("SubmixEffectFilterPreset", "SetFilterCutoffFrequency");
|
|
|
|
Params::SubmixEffectFilterPreset_SetFilterCutoffFrequency Parms{};
|
|
|
|
Parms.InFrequency = InFrequency;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SubmixEffectFilterPreset.SetFilterCutoffFrequencyMod
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float InFrequency (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void USubmixEffectFilterPreset::SetFilterCutoffFrequencyMod(float InFrequency)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("SubmixEffectFilterPreset", "SetFilterCutoffFrequencyMod");
|
|
|
|
Params::SubmixEffectFilterPreset_SetFilterCutoffFrequencyMod Parms{};
|
|
|
|
Parms.InFrequency = InFrequency;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SubmixEffectFilterPreset.SetFilterQ
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float InQ (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void USubmixEffectFilterPreset::SetFilterQ(float InQ)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("SubmixEffectFilterPreset", "SetFilterQ");
|
|
|
|
Params::SubmixEffectFilterPreset_SetFilterQ Parms{};
|
|
|
|
Parms.InQ = InQ;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SubmixEffectFilterPreset.SetFilterQMod
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float InQ (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void USubmixEffectFilterPreset::SetFilterQMod(float InQ)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("SubmixEffectFilterPreset", "SetFilterQMod");
|
|
|
|
Params::SubmixEffectFilterPreset_SetFilterQMod Parms{};
|
|
|
|
Parms.InQ = InQ;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SubmixEffectFilterPreset.SetFilterType
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// ESubmixFilterType InType (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void USubmixEffectFilterPreset::SetFilterType(ESubmixFilterType InType)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("SubmixEffectFilterPreset", "SetFilterType");
|
|
|
|
Params::SubmixEffectFilterPreset_SetFilterType Parms{};
|
|
|
|
Parms.InType = InType;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SubmixEffectFilterPreset.SetSettings
|
|
// (Final, Native, Public, HasOutParams, BlueprintCallable)
|
|
// Parameters:
|
|
// const struct FSubmixEffectFilterSettings&InSettings (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
|
|
void USubmixEffectFilterPreset::SetSettings(const struct FSubmixEffectFilterSettings& InSettings)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("SubmixEffectFilterPreset", "SetSettings");
|
|
|
|
Params::SubmixEffectFilterPreset_SetSettings Parms{};
|
|
|
|
Parms.InSettings = std::move(InSettings);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SubmixEffectFlexiverbPreset.SetSettings
|
|
// (Final, Native, Public, HasOutParams, BlueprintCallable)
|
|
// Parameters:
|
|
// const struct FSubmixEffectFlexiverbSettings&InSettings (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
|
|
void USubmixEffectFlexiverbPreset::SetSettings(const struct FSubmixEffectFlexiverbSettings& InSettings)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("SubmixEffectFlexiverbPreset", "SetSettings");
|
|
|
|
Params::SubmixEffectFlexiverbPreset_SetSettings Parms{};
|
|
|
|
Parms.InSettings = std::move(InSettings);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SubmixEffectMultibandCompressorPreset.ResetKey
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
|
|
void USubmixEffectMultibandCompressorPreset::ResetKey()
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("SubmixEffectMultibandCompressorPreset", "ResetKey");
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, nullptr);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SubmixEffectMultibandCompressorPreset.SetAudioBus
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UAudioBus* AudioBus (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void USubmixEffectMultibandCompressorPreset::SetAudioBus(class UAudioBus* AudioBus)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("SubmixEffectMultibandCompressorPreset", "SetAudioBus");
|
|
|
|
Params::SubmixEffectMultibandCompressorPreset_SetAudioBus Parms{};
|
|
|
|
Parms.AudioBus = AudioBus;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SubmixEffectMultibandCompressorPreset.SetExternalSubmix
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class USoundSubmix* Submix (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void USubmixEffectMultibandCompressorPreset::SetExternalSubmix(class USoundSubmix* Submix)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("SubmixEffectMultibandCompressorPreset", "SetExternalSubmix");
|
|
|
|
Params::SubmixEffectMultibandCompressorPreset_SetExternalSubmix Parms{};
|
|
|
|
Parms.Submix = Submix;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SubmixEffectMultibandCompressorPreset.SetSettings
|
|
// (Final, Native, Public, HasOutParams, BlueprintCallable)
|
|
// Parameters:
|
|
// const struct FSubmixEffectMultibandCompressorSettings&InSettings (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
|
|
|
|
void USubmixEffectMultibandCompressorPreset::SetSettings(const struct FSubmixEffectMultibandCompressorSettings& InSettings)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("SubmixEffectMultibandCompressorPreset", "SetSettings");
|
|
|
|
Params::SubmixEffectMultibandCompressorPreset_SetSettings Parms{};
|
|
|
|
Parms.InSettings = std::move(InSettings);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SubmixEffectStereoDelayPreset.SetSettings
|
|
// (Final, Native, Public, HasOutParams, BlueprintCallable)
|
|
// Parameters:
|
|
// const struct FSubmixEffectStereoDelaySettings&InSettings (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
|
|
void USubmixEffectStereoDelayPreset::SetSettings(const struct FSubmixEffectStereoDelaySettings& InSettings)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("SubmixEffectStereoDelayPreset", "SetSettings");
|
|
|
|
Params::SubmixEffectStereoDelayPreset_SetSettings Parms{};
|
|
|
|
Parms.InSettings = std::move(InSettings);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SubmixEffectStereoToQuadPreset.SetSettings
|
|
// (Final, Native, Public, HasOutParams, BlueprintCallable)
|
|
// Parameters:
|
|
// const struct FSubmixEffectStereoToQuadSettings&InSettings (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
|
|
void USubmixEffectStereoToQuadPreset::SetSettings(const struct FSubmixEffectStereoToQuadSettings& InSettings)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("SubmixEffectStereoToQuadPreset", "SetSettings");
|
|
|
|
Params::SubmixEffectStereoToQuadPreset_SetSettings Parms{};
|
|
|
|
Parms.InSettings = std::move(InSettings);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SubmixEffectTapDelayPreset.AddTap
|
|
// (Final, Native, Public, HasOutParams, BlueprintCallable)
|
|
// Parameters:
|
|
// int32* TapId (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void USubmixEffectTapDelayPreset::AddTap(int32* TapId)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("SubmixEffectTapDelayPreset", "AddTap");
|
|
|
|
Params::SubmixEffectTapDelayPreset_AddTap Parms{};
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
if (TapId != nullptr)
|
|
*TapId = Parms.TapId;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SubmixEffectTapDelayPreset.GetMaxDelayInMilliseconds
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
float USubmixEffectTapDelayPreset::GetMaxDelayInMilliseconds()
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("SubmixEffectTapDelayPreset", "GetMaxDelayInMilliseconds");
|
|
|
|
Params::SubmixEffectTapDelayPreset_GetMaxDelayInMilliseconds Parms{};
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SubmixEffectTapDelayPreset.GetTap
|
|
// (Final, Native, Public, HasOutParams, BlueprintCallable)
|
|
// Parameters:
|
|
// int32 TapId (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// struct FTapDelayInfo* TapInfo (Parm, OutParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
|
|
void USubmixEffectTapDelayPreset::GetTap(int32 TapId, struct FTapDelayInfo* TapInfo)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("SubmixEffectTapDelayPreset", "GetTap");
|
|
|
|
Params::SubmixEffectTapDelayPreset_GetTap Parms{};
|
|
|
|
Parms.TapId = TapId;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
if (TapInfo != nullptr)
|
|
*TapInfo = std::move(Parms.TapInfo);
|
|
}
|
|
|
|
|
|
// Function Synthesis.SubmixEffectTapDelayPreset.GetTapIds
|
|
// (Final, Native, Public, HasOutParams, BlueprintCallable)
|
|
// Parameters:
|
|
// TArray<int32>* TapIds (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)
|
|
|
|
void USubmixEffectTapDelayPreset::GetTapIds(TArray<int32>* TapIds)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("SubmixEffectTapDelayPreset", "GetTapIds");
|
|
|
|
Params::SubmixEffectTapDelayPreset_GetTapIds Parms{};
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
if (TapIds != nullptr)
|
|
*TapIds = std::move(Parms.TapIds);
|
|
}
|
|
|
|
|
|
// Function Synthesis.SubmixEffectTapDelayPreset.RemoveTap
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// int32 TapId (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void USubmixEffectTapDelayPreset::RemoveTap(int32 TapId)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("SubmixEffectTapDelayPreset", "RemoveTap");
|
|
|
|
Params::SubmixEffectTapDelayPreset_RemoveTap Parms{};
|
|
|
|
Parms.TapId = TapId;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SubmixEffectTapDelayPreset.SetInterpolationTime
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float Time (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void USubmixEffectTapDelayPreset::SetInterpolationTime(float Time)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("SubmixEffectTapDelayPreset", "SetInterpolationTime");
|
|
|
|
Params::SubmixEffectTapDelayPreset_SetInterpolationTime Parms{};
|
|
|
|
Parms.Time = Time;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SubmixEffectTapDelayPreset.SetSettings
|
|
// (Final, Native, Public, HasOutParams, BlueprintCallable)
|
|
// Parameters:
|
|
// const struct FSubmixEffectTapDelaySettings&InSettings (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
|
|
|
|
void USubmixEffectTapDelayPreset::SetSettings(const struct FSubmixEffectTapDelaySettings& InSettings)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("SubmixEffectTapDelayPreset", "SetSettings");
|
|
|
|
Params::SubmixEffectTapDelayPreset_SetSettings Parms{};
|
|
|
|
Parms.InSettings = std::move(InSettings);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SubmixEffectTapDelayPreset.SetTap
|
|
// (Final, Native, Public, HasOutParams, BlueprintCallable)
|
|
// Parameters:
|
|
// int32 TapId (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// const struct FTapDelayInfo& TapInfo (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
|
|
void USubmixEffectTapDelayPreset::SetTap(int32 TapId, const struct FTapDelayInfo& TapInfo)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("SubmixEffectTapDelayPreset", "SetTap");
|
|
|
|
Params::SubmixEffectTapDelayPreset_SetTap Parms{};
|
|
|
|
Parms.TapId = TapId;
|
|
Parms.TapInfo = std::move(TapInfo);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.GranularSynth.NoteOff
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// const float Note (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// const bool bKill (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UGranularSynth::NoteOff(const float Note, const bool bKill)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("GranularSynth", "NoteOff");
|
|
|
|
Params::GranularSynth_NoteOff Parms{};
|
|
|
|
Parms.Note = Note;
|
|
Parms.bKill = bKill;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.GranularSynth.NoteOn
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// const float Note (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// const int32 Velocity (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// const float Duration (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UGranularSynth::NoteOn(const float Note, const int32 Velocity, const float Duration)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("GranularSynth", "NoteOn");
|
|
|
|
Params::GranularSynth_NoteOn Parms{};
|
|
|
|
Parms.Note = Note;
|
|
Parms.Velocity = Velocity;
|
|
Parms.Duration = Duration;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.GranularSynth.SetAttackTime
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// const float AttackTimeMsec (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UGranularSynth::SetAttackTime(const float AttackTimeMsec)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("GranularSynth", "SetAttackTime");
|
|
|
|
Params::GranularSynth_SetAttackTime Parms{};
|
|
|
|
Parms.AttackTimeMsec = AttackTimeMsec;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.GranularSynth.SetDecayTime
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// const float DecayTimeMsec (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UGranularSynth::SetDecayTime(const float DecayTimeMsec)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("GranularSynth", "SetDecayTime");
|
|
|
|
Params::GranularSynth_SetDecayTime Parms{};
|
|
|
|
Parms.DecayTimeMsec = DecayTimeMsec;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.GranularSynth.SetGrainDuration
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// const float BaseDurationMsec (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// const struct FVector2D& DurationRange (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UGranularSynth::SetGrainDuration(const float BaseDurationMsec, const struct FVector2D& DurationRange)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("GranularSynth", "SetGrainDuration");
|
|
|
|
Params::GranularSynth_SetGrainDuration Parms{};
|
|
|
|
Parms.BaseDurationMsec = BaseDurationMsec;
|
|
Parms.DurationRange = std::move(DurationRange);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.GranularSynth.SetGrainEnvelopeType
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// const EGranularSynthEnvelopeType EnvelopeType (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UGranularSynth::SetGrainEnvelopeType(const EGranularSynthEnvelopeType EnvelopeType)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("GranularSynth", "SetGrainEnvelopeType");
|
|
|
|
Params::GranularSynth_SetGrainEnvelopeType Parms{};
|
|
|
|
Parms.EnvelopeType = EnvelopeType;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.GranularSynth.SetGrainPan
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// const float BasePan (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// const struct FVector2D& PanRange (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UGranularSynth::SetGrainPan(const float BasePan, const struct FVector2D& PanRange)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("GranularSynth", "SetGrainPan");
|
|
|
|
Params::GranularSynth_SetGrainPan Parms{};
|
|
|
|
Parms.BasePan = BasePan;
|
|
Parms.PanRange = std::move(PanRange);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.GranularSynth.SetGrainPitch
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// const float BasePitch (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// const struct FVector2D& PitchRange (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UGranularSynth::SetGrainPitch(const float BasePitch, const struct FVector2D& PitchRange)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("GranularSynth", "SetGrainPitch");
|
|
|
|
Params::GranularSynth_SetGrainPitch Parms{};
|
|
|
|
Parms.BasePitch = BasePitch;
|
|
Parms.PitchRange = std::move(PitchRange);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.GranularSynth.SetGrainProbability
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// const float InGrainProbability (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UGranularSynth::SetGrainProbability(const float InGrainProbability)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("GranularSynth", "SetGrainProbability");
|
|
|
|
Params::GranularSynth_SetGrainProbability Parms{};
|
|
|
|
Parms.InGrainProbability = InGrainProbability;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.GranularSynth.SetGrainsPerSecond
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// const float InGrainsPerSecond (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UGranularSynth::SetGrainsPerSecond(const float InGrainsPerSecond)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("GranularSynth", "SetGrainsPerSecond");
|
|
|
|
Params::GranularSynth_SetGrainsPerSecond Parms{};
|
|
|
|
Parms.InGrainsPerSecond = InGrainsPerSecond;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.GranularSynth.SetGrainVolume
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// const float BaseVolume (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// const struct FVector2D& VolumeRange (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UGranularSynth::SetGrainVolume(const float BaseVolume, const struct FVector2D& VolumeRange)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("GranularSynth", "SetGrainVolume");
|
|
|
|
Params::GranularSynth_SetGrainVolume Parms{};
|
|
|
|
Parms.BaseVolume = BaseVolume;
|
|
Parms.VolumeRange = std::move(VolumeRange);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.GranularSynth.SetPlaybackSpeed
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// const float InPlayheadRate (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UGranularSynth::SetPlaybackSpeed(const float InPlayheadRate)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("GranularSynth", "SetPlaybackSpeed");
|
|
|
|
Params::GranularSynth_SetPlaybackSpeed Parms{};
|
|
|
|
Parms.InPlayheadRate = InPlayheadRate;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.GranularSynth.SetPlayheadTime
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// const float InPositionSec (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// const float LerpTimeSec (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// EGranularSynthSeekType SeekType (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UGranularSynth::SetPlayheadTime(const float InPositionSec, const float LerpTimeSec, EGranularSynthSeekType SeekType)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("GranularSynth", "SetPlayheadTime");
|
|
|
|
Params::GranularSynth_SetPlayheadTime Parms{};
|
|
|
|
Parms.InPositionSec = InPositionSec;
|
|
Parms.LerpTimeSec = LerpTimeSec;
|
|
Parms.SeekType = SeekType;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.GranularSynth.SetReleaseTimeMsec
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// const float ReleaseTimeMsec (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UGranularSynth::SetReleaseTimeMsec(const float ReleaseTimeMsec)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("GranularSynth", "SetReleaseTimeMsec");
|
|
|
|
Params::GranularSynth_SetReleaseTimeMsec Parms{};
|
|
|
|
Parms.ReleaseTimeMsec = ReleaseTimeMsec;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.GranularSynth.SetScrubMode
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// const bool bScrubMode (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UGranularSynth::SetScrubMode(const bool bScrubMode)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("GranularSynth", "SetScrubMode");
|
|
|
|
Params::GranularSynth_SetScrubMode Parms{};
|
|
|
|
Parms.bScrubMode = bScrubMode;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.GranularSynth.SetSoundWave
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class USoundWave* InSoundWave (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UGranularSynth::SetSoundWave(class USoundWave* InSoundWave)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("GranularSynth", "SetSoundWave");
|
|
|
|
Params::GranularSynth_SetSoundWave Parms{};
|
|
|
|
Parms.InSoundWave = InSoundWave;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.GranularSynth.SetSustainGain
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// const float SustainGain (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UGranularSynth::SetSustainGain(const float SustainGain)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("GranularSynth", "SetSustainGain");
|
|
|
|
Params::GranularSynth_SetSustainGain Parms{};
|
|
|
|
Parms.SustainGain = SustainGain;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.GranularSynth.GetCurrentPlayheadTime
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
float UGranularSynth::GetCurrentPlayheadTime() const
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("GranularSynth", "GetCurrentPlayheadTime");
|
|
|
|
Params::GranularSynth_GetCurrentPlayheadTime Parms{};
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Synthesis.GranularSynth.GetSampleDuration
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
float UGranularSynth::GetSampleDuration() const
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("GranularSynth", "GetSampleDuration");
|
|
|
|
Params::GranularSynth_GetSampleDuration Parms{};
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Synthesis.GranularSynth.IsLoaded
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
bool UGranularSynth::IsLoaded() const
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("GranularSynth", "IsLoaded");
|
|
|
|
Params::GranularSynth_IsLoaded Parms{};
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SynthComponentMonoWaveTable.GetCurveTangent
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// int32 TableIndex (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
float USynthComponentMonoWaveTable::GetCurveTangent(int32 TableIndex)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("SynthComponentMonoWaveTable", "GetCurveTangent");
|
|
|
|
Params::SynthComponentMonoWaveTable_GetCurveTangent Parms{};
|
|
|
|
Parms.TableIndex = TableIndex;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SynthComponentMonoWaveTable.GetNumTableEntries
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// int32 ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
int32 USynthComponentMonoWaveTable::GetNumTableEntries()
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("SynthComponentMonoWaveTable", "GetNumTableEntries");
|
|
|
|
Params::SynthComponentMonoWaveTable_GetNumTableEntries Parms{};
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SynthComponentMonoWaveTable.NoteOff
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// const float InMidiNote (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void USynthComponentMonoWaveTable::NoteOff(const float InMidiNote)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("SynthComponentMonoWaveTable", "NoteOff");
|
|
|
|
Params::SynthComponentMonoWaveTable_NoteOff Parms{};
|
|
|
|
Parms.InMidiNote = InMidiNote;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SynthComponentMonoWaveTable.NoteOn
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// const float InMidiNote (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// const float InVelocity (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void USynthComponentMonoWaveTable::NoteOn(const float InMidiNote, const float InVelocity)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("SynthComponentMonoWaveTable", "NoteOn");
|
|
|
|
Params::SynthComponentMonoWaveTable_NoteOn Parms{};
|
|
|
|
Parms.InMidiNote = InMidiNote;
|
|
Parms.InVelocity = InVelocity;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SynthComponentMonoWaveTable.RefreshAllWaveTables
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
|
|
void USynthComponentMonoWaveTable::RefreshAllWaveTables()
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("SynthComponentMonoWaveTable", "RefreshAllWaveTables");
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, nullptr);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SynthComponentMonoWaveTable.RefreshWaveTable
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// int32 Index_0 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void USynthComponentMonoWaveTable::RefreshWaveTable(int32 Index_0)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("SynthComponentMonoWaveTable", "RefreshWaveTable");
|
|
|
|
Params::SynthComponentMonoWaveTable_RefreshWaveTable Parms{};
|
|
|
|
Parms.Index_0 = Index_0;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SynthComponentMonoWaveTable.SetAmpEnvelopeAttackTime
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// const float InAttackTimeMsec (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void USynthComponentMonoWaveTable::SetAmpEnvelopeAttackTime(const float InAttackTimeMsec)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("SynthComponentMonoWaveTable", "SetAmpEnvelopeAttackTime");
|
|
|
|
Params::SynthComponentMonoWaveTable_SetAmpEnvelopeAttackTime Parms{};
|
|
|
|
Parms.InAttackTimeMsec = InAttackTimeMsec;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SynthComponentMonoWaveTable.SetAmpEnvelopeBiasDepth
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// const float InDepth (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void USynthComponentMonoWaveTable::SetAmpEnvelopeBiasDepth(const float InDepth)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("SynthComponentMonoWaveTable", "SetAmpEnvelopeBiasDepth");
|
|
|
|
Params::SynthComponentMonoWaveTable_SetAmpEnvelopeBiasDepth Parms{};
|
|
|
|
Parms.InDepth = InDepth;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SynthComponentMonoWaveTable.SetAmpEnvelopeBiasInvert
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// const bool bInBiasInvert (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void USynthComponentMonoWaveTable::SetAmpEnvelopeBiasInvert(const bool bInBiasInvert)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("SynthComponentMonoWaveTable", "SetAmpEnvelopeBiasInvert");
|
|
|
|
Params::SynthComponentMonoWaveTable_SetAmpEnvelopeBiasInvert Parms{};
|
|
|
|
Parms.bInBiasInvert = bInBiasInvert;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SynthComponentMonoWaveTable.SetAmpEnvelopeDecayTime
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// const float InDecayTimeMsec (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void USynthComponentMonoWaveTable::SetAmpEnvelopeDecayTime(const float InDecayTimeMsec)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("SynthComponentMonoWaveTable", "SetAmpEnvelopeDecayTime");
|
|
|
|
Params::SynthComponentMonoWaveTable_SetAmpEnvelopeDecayTime Parms{};
|
|
|
|
Parms.InDecayTimeMsec = InDecayTimeMsec;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SynthComponentMonoWaveTable.SetAmpEnvelopeDepth
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// const float InDepth (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void USynthComponentMonoWaveTable::SetAmpEnvelopeDepth(const float InDepth)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("SynthComponentMonoWaveTable", "SetAmpEnvelopeDepth");
|
|
|
|
Params::SynthComponentMonoWaveTable_SetAmpEnvelopeDepth Parms{};
|
|
|
|
Parms.InDepth = InDepth;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SynthComponentMonoWaveTable.SetAmpEnvelopeInvert
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// const bool bInInvert (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void USynthComponentMonoWaveTable::SetAmpEnvelopeInvert(const bool bInInvert)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("SynthComponentMonoWaveTable", "SetAmpEnvelopeInvert");
|
|
|
|
Params::SynthComponentMonoWaveTable_SetAmpEnvelopeInvert Parms{};
|
|
|
|
Parms.bInInvert = bInInvert;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SynthComponentMonoWaveTable.SetAmpEnvelopeReleaseTime
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// const float InReleaseTimeMsec (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void USynthComponentMonoWaveTable::SetAmpEnvelopeReleaseTime(const float InReleaseTimeMsec)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("SynthComponentMonoWaveTable", "SetAmpEnvelopeReleaseTime");
|
|
|
|
Params::SynthComponentMonoWaveTable_SetAmpEnvelopeReleaseTime Parms{};
|
|
|
|
Parms.InReleaseTimeMsec = InReleaseTimeMsec;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SynthComponentMonoWaveTable.SetAmpEnvelopeSustainGain
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// const float InSustainGain (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void USynthComponentMonoWaveTable::SetAmpEnvelopeSustainGain(const float InSustainGain)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("SynthComponentMonoWaveTable", "SetAmpEnvelopeSustainGain");
|
|
|
|
Params::SynthComponentMonoWaveTable_SetAmpEnvelopeSustainGain Parms{};
|
|
|
|
Parms.InSustainGain = InSustainGain;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SynthComponentMonoWaveTable.SetCurveInterpolationType
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// ECurveInterpolationType InterpolationType (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// int32 TableIndex (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
bool USynthComponentMonoWaveTable::SetCurveInterpolationType(ECurveInterpolationType InterpolationType, int32 TableIndex)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("SynthComponentMonoWaveTable", "SetCurveInterpolationType");
|
|
|
|
Params::SynthComponentMonoWaveTable_SetCurveInterpolationType Parms{};
|
|
|
|
Parms.InterpolationType = InterpolationType;
|
|
Parms.TableIndex = TableIndex;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SynthComponentMonoWaveTable.SetCurveTangent
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// int32 TableIndex (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float InNewTangent (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
bool USynthComponentMonoWaveTable::SetCurveTangent(int32 TableIndex, float InNewTangent)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("SynthComponentMonoWaveTable", "SetCurveTangent");
|
|
|
|
Params::SynthComponentMonoWaveTable_SetCurveTangent Parms{};
|
|
|
|
Parms.TableIndex = TableIndex;
|
|
Parms.InNewTangent = InNewTangent;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SynthComponentMonoWaveTable.SetCurveValue
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// int32 TableIndex (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// int32 KeyframeIndex (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// const float NewValue (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
bool USynthComponentMonoWaveTable::SetCurveValue(int32 TableIndex, int32 KeyframeIndex, const float NewValue)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("SynthComponentMonoWaveTable", "SetCurveValue");
|
|
|
|
Params::SynthComponentMonoWaveTable_SetCurveValue Parms{};
|
|
|
|
Parms.TableIndex = TableIndex;
|
|
Parms.KeyframeIndex = KeyframeIndex;
|
|
Parms.NewValue = NewValue;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SynthComponentMonoWaveTable.SetFilterEnvelopeAttackTime
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// const float InAttackTimeMsec (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void USynthComponentMonoWaveTable::SetFilterEnvelopeAttackTime(const float InAttackTimeMsec)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("SynthComponentMonoWaveTable", "SetFilterEnvelopeAttackTime");
|
|
|
|
Params::SynthComponentMonoWaveTable_SetFilterEnvelopeAttackTime Parms{};
|
|
|
|
Parms.InAttackTimeMsec = InAttackTimeMsec;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SynthComponentMonoWaveTable.SetFilterEnvelopeBiasDepth
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// const float InDepth (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void USynthComponentMonoWaveTable::SetFilterEnvelopeBiasDepth(const float InDepth)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("SynthComponentMonoWaveTable", "SetFilterEnvelopeBiasDepth");
|
|
|
|
Params::SynthComponentMonoWaveTable_SetFilterEnvelopeBiasDepth Parms{};
|
|
|
|
Parms.InDepth = InDepth;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SynthComponentMonoWaveTable.SetFilterEnvelopeBiasInvert
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// const bool bInBiasInvert (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void USynthComponentMonoWaveTable::SetFilterEnvelopeBiasInvert(const bool bInBiasInvert)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("SynthComponentMonoWaveTable", "SetFilterEnvelopeBiasInvert");
|
|
|
|
Params::SynthComponentMonoWaveTable_SetFilterEnvelopeBiasInvert Parms{};
|
|
|
|
Parms.bInBiasInvert = bInBiasInvert;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SynthComponentMonoWaveTable.SetFilterEnvelopeDepth
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// const float InDepth (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void USynthComponentMonoWaveTable::SetFilterEnvelopeDepth(const float InDepth)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("SynthComponentMonoWaveTable", "SetFilterEnvelopeDepth");
|
|
|
|
Params::SynthComponentMonoWaveTable_SetFilterEnvelopeDepth Parms{};
|
|
|
|
Parms.InDepth = InDepth;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SynthComponentMonoWaveTable.SetFilterEnvelopeInvert
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// const bool bInInvert (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void USynthComponentMonoWaveTable::SetFilterEnvelopeInvert(const bool bInInvert)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("SynthComponentMonoWaveTable", "SetFilterEnvelopeInvert");
|
|
|
|
Params::SynthComponentMonoWaveTable_SetFilterEnvelopeInvert Parms{};
|
|
|
|
Parms.bInInvert = bInInvert;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SynthComponentMonoWaveTable.SetFilterEnvelopenDecayTime
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// const float InDecayTimeMsec (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void USynthComponentMonoWaveTable::SetFilterEnvelopenDecayTime(const float InDecayTimeMsec)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("SynthComponentMonoWaveTable", "SetFilterEnvelopenDecayTime");
|
|
|
|
Params::SynthComponentMonoWaveTable_SetFilterEnvelopenDecayTime Parms{};
|
|
|
|
Parms.InDecayTimeMsec = InDecayTimeMsec;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SynthComponentMonoWaveTable.SetFilterEnvelopeReleaseTime
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// const float InReleaseTimeMsec (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void USynthComponentMonoWaveTable::SetFilterEnvelopeReleaseTime(const float InReleaseTimeMsec)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("SynthComponentMonoWaveTable", "SetFilterEnvelopeReleaseTime");
|
|
|
|
Params::SynthComponentMonoWaveTable_SetFilterEnvelopeReleaseTime Parms{};
|
|
|
|
Parms.InReleaseTimeMsec = InReleaseTimeMsec;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SynthComponentMonoWaveTable.SetFilterEnvelopeSustainGain
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// const float InSustainGain (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void USynthComponentMonoWaveTable::SetFilterEnvelopeSustainGain(const float InSustainGain)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("SynthComponentMonoWaveTable", "SetFilterEnvelopeSustainGain");
|
|
|
|
Params::SynthComponentMonoWaveTable_SetFilterEnvelopeSustainGain Parms{};
|
|
|
|
Parms.InSustainGain = InSustainGain;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SynthComponentMonoWaveTable.SetFrequency
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// const float FrequencyHz (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void USynthComponentMonoWaveTable::SetFrequency(const float FrequencyHz)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("SynthComponentMonoWaveTable", "SetFrequency");
|
|
|
|
Params::SynthComponentMonoWaveTable_SetFrequency Parms{};
|
|
|
|
Parms.FrequencyHz = FrequencyHz;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SynthComponentMonoWaveTable.SetFrequencyPitchBend
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// const float FrequencyOffsetCents (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void USynthComponentMonoWaveTable::SetFrequencyPitchBend(const float FrequencyOffsetCents)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("SynthComponentMonoWaveTable", "SetFrequencyPitchBend");
|
|
|
|
Params::SynthComponentMonoWaveTable_SetFrequencyPitchBend Parms{};
|
|
|
|
Parms.FrequencyOffsetCents = FrequencyOffsetCents;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SynthComponentMonoWaveTable.SetFrequencyWithMidiNote
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// const float InMidiNote (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void USynthComponentMonoWaveTable::SetFrequencyWithMidiNote(const float InMidiNote)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("SynthComponentMonoWaveTable", "SetFrequencyWithMidiNote");
|
|
|
|
Params::SynthComponentMonoWaveTable_SetFrequencyWithMidiNote Parms{};
|
|
|
|
Parms.InMidiNote = InMidiNote;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SynthComponentMonoWaveTable.SetLowPassFilterResonance
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float InNewQ (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void USynthComponentMonoWaveTable::SetLowPassFilterResonance(float InNewQ)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("SynthComponentMonoWaveTable", "SetLowPassFilterResonance");
|
|
|
|
Params::SynthComponentMonoWaveTable_SetLowPassFilterResonance Parms{};
|
|
|
|
Parms.InNewQ = InNewQ;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SynthComponentMonoWaveTable.SetPositionEnvelopeAttackTime
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// const float InAttackTimeMsec (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void USynthComponentMonoWaveTable::SetPositionEnvelopeAttackTime(const float InAttackTimeMsec)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("SynthComponentMonoWaveTable", "SetPositionEnvelopeAttackTime");
|
|
|
|
Params::SynthComponentMonoWaveTable_SetPositionEnvelopeAttackTime Parms{};
|
|
|
|
Parms.InAttackTimeMsec = InAttackTimeMsec;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SynthComponentMonoWaveTable.SetPositionEnvelopeBiasDepth
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// const float InDepth (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void USynthComponentMonoWaveTable::SetPositionEnvelopeBiasDepth(const float InDepth)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("SynthComponentMonoWaveTable", "SetPositionEnvelopeBiasDepth");
|
|
|
|
Params::SynthComponentMonoWaveTable_SetPositionEnvelopeBiasDepth Parms{};
|
|
|
|
Parms.InDepth = InDepth;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SynthComponentMonoWaveTable.SetPositionEnvelopeBiasInvert
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// const bool bInBiasInvert (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void USynthComponentMonoWaveTable::SetPositionEnvelopeBiasInvert(const bool bInBiasInvert)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("SynthComponentMonoWaveTable", "SetPositionEnvelopeBiasInvert");
|
|
|
|
Params::SynthComponentMonoWaveTable_SetPositionEnvelopeBiasInvert Parms{};
|
|
|
|
Parms.bInBiasInvert = bInBiasInvert;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SynthComponentMonoWaveTable.SetPositionEnvelopeDecayTime
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// const float InDecayTimeMsec (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void USynthComponentMonoWaveTable::SetPositionEnvelopeDecayTime(const float InDecayTimeMsec)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("SynthComponentMonoWaveTable", "SetPositionEnvelopeDecayTime");
|
|
|
|
Params::SynthComponentMonoWaveTable_SetPositionEnvelopeDecayTime Parms{};
|
|
|
|
Parms.InDecayTimeMsec = InDecayTimeMsec;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SynthComponentMonoWaveTable.SetPositionEnvelopeDepth
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// const float InDepth (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void USynthComponentMonoWaveTable::SetPositionEnvelopeDepth(const float InDepth)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("SynthComponentMonoWaveTable", "SetPositionEnvelopeDepth");
|
|
|
|
Params::SynthComponentMonoWaveTable_SetPositionEnvelopeDepth Parms{};
|
|
|
|
Parms.InDepth = InDepth;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SynthComponentMonoWaveTable.SetPositionEnvelopeInvert
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// const bool bInInvert (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void USynthComponentMonoWaveTable::SetPositionEnvelopeInvert(const bool bInInvert)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("SynthComponentMonoWaveTable", "SetPositionEnvelopeInvert");
|
|
|
|
Params::SynthComponentMonoWaveTable_SetPositionEnvelopeInvert Parms{};
|
|
|
|
Parms.bInInvert = bInInvert;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SynthComponentMonoWaveTable.SetPositionEnvelopeReleaseTime
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// const float InReleaseTimeMsec (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void USynthComponentMonoWaveTable::SetPositionEnvelopeReleaseTime(const float InReleaseTimeMsec)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("SynthComponentMonoWaveTable", "SetPositionEnvelopeReleaseTime");
|
|
|
|
Params::SynthComponentMonoWaveTable_SetPositionEnvelopeReleaseTime Parms{};
|
|
|
|
Parms.InReleaseTimeMsec = InReleaseTimeMsec;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SynthComponentMonoWaveTable.SetPositionEnvelopeSustainGain
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// const float InSustainGain (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void USynthComponentMonoWaveTable::SetPositionEnvelopeSustainGain(const float InSustainGain)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("SynthComponentMonoWaveTable", "SetPositionEnvelopeSustainGain");
|
|
|
|
Params::SynthComponentMonoWaveTable_SetPositionEnvelopeSustainGain Parms{};
|
|
|
|
Parms.InSustainGain = InSustainGain;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SynthComponentMonoWaveTable.SetPosLfoDepth
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// const float InLfoDepth (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void USynthComponentMonoWaveTable::SetPosLfoDepth(const float InLfoDepth)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("SynthComponentMonoWaveTable", "SetPosLfoDepth");
|
|
|
|
Params::SynthComponentMonoWaveTable_SetPosLfoDepth Parms{};
|
|
|
|
Parms.InLfoDepth = InLfoDepth;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SynthComponentMonoWaveTable.SetPosLfoFrequency
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// const float InLfoFrequency (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void USynthComponentMonoWaveTable::SetPosLfoFrequency(const float InLfoFrequency)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("SynthComponentMonoWaveTable", "SetPosLfoFrequency");
|
|
|
|
Params::SynthComponentMonoWaveTable_SetPosLfoFrequency Parms{};
|
|
|
|
Parms.InLfoFrequency = InLfoFrequency;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SynthComponentMonoWaveTable.SetPosLfoType
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// const ESynthLFOType InLfoType (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void USynthComponentMonoWaveTable::SetPosLfoType(const ESynthLFOType InLfoType)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("SynthComponentMonoWaveTable", "SetPosLfoType");
|
|
|
|
Params::SynthComponentMonoWaveTable_SetPosLfoType Parms{};
|
|
|
|
Parms.InLfoType = InLfoType;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SynthComponentMonoWaveTable.SetSustainPedalState
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool InSustainPedalState (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void USynthComponentMonoWaveTable::SetSustainPedalState(bool InSustainPedalState)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("SynthComponentMonoWaveTable", "SetSustainPedalState");
|
|
|
|
Params::SynthComponentMonoWaveTable_SetSustainPedalState Parms{};
|
|
|
|
Parms.InSustainPedalState = InSustainPedalState;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SynthComponentMonoWaveTable.SetWaveTablePosition
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float InPosition (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void USynthComponentMonoWaveTable::SetWaveTablePosition(float InPosition)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("SynthComponentMonoWaveTable", "SetWaveTablePosition");
|
|
|
|
Params::SynthComponentMonoWaveTable_SetWaveTablePosition Parms{};
|
|
|
|
Parms.InPosition = InPosition;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SynthComponentMonoWaveTable.GetKeyFrameValuesForTable
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float TableIndex (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// TArray<float> ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)
|
|
|
|
TArray<float> USynthComponentMonoWaveTable::GetKeyFrameValuesForTable(float TableIndex) const
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("SynthComponentMonoWaveTable", "GetKeyFrameValuesForTable");
|
|
|
|
Params::SynthComponentMonoWaveTable_GetKeyFrameValuesForTable Parms{};
|
|
|
|
Parms.TableIndex = TableIndex;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SynthComponentMonoWaveTable.GetMaxTableIndex
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// int32 ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
int32 USynthComponentMonoWaveTable::GetMaxTableIndex() const
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("SynthComponentMonoWaveTable", "GetMaxTableIndex");
|
|
|
|
Params::SynthComponentMonoWaveTable_GetMaxTableIndex Parms{};
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SynthComponentToneGenerator.SetFrequency
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float InFrequency (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void USynthComponentToneGenerator::SetFrequency(float InFrequency)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("SynthComponentToneGenerator", "SetFrequency");
|
|
|
|
Params::SynthComponentToneGenerator_SetFrequency Parms{};
|
|
|
|
Parms.InFrequency = InFrequency;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SynthComponentToneGenerator.SetVolume
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float InVolume (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void USynthComponentToneGenerator::SetVolume(float InVolume)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("SynthComponentToneGenerator", "SetVolume");
|
|
|
|
Params::SynthComponentToneGenerator_SetVolume Parms{};
|
|
|
|
Parms.InVolume = InVolume;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SynthSamplePlayer.SeekToTime
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float TimeSec (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// ESamplePlayerSeekType SeekType (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// bool bWrap (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void USynthSamplePlayer::SeekToTime(float TimeSec, ESamplePlayerSeekType SeekType, bool bWrap)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("SynthSamplePlayer", "SeekToTime");
|
|
|
|
Params::SynthSamplePlayer_SeekToTime Parms{};
|
|
|
|
Parms.TimeSec = TimeSec;
|
|
Parms.SeekType = SeekType;
|
|
Parms.bWrap = bWrap;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SynthSamplePlayer.SetPitch
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float InPitch (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float TimeSec (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void USynthSamplePlayer::SetPitch(float InPitch, float TimeSec)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("SynthSamplePlayer", "SetPitch");
|
|
|
|
Params::SynthSamplePlayer_SetPitch Parms{};
|
|
|
|
Parms.InPitch = InPitch;
|
|
Parms.TimeSec = TimeSec;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SynthSamplePlayer.SetScrubMode
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bScrubMode (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void USynthSamplePlayer::SetScrubMode(bool bScrubMode)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("SynthSamplePlayer", "SetScrubMode");
|
|
|
|
Params::SynthSamplePlayer_SetScrubMode Parms{};
|
|
|
|
Parms.bScrubMode = bScrubMode;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SynthSamplePlayer.SetScrubTimeWidth
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float InScrubTimeWidthSec (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void USynthSamplePlayer::SetScrubTimeWidth(float InScrubTimeWidthSec)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("SynthSamplePlayer", "SetScrubTimeWidth");
|
|
|
|
Params::SynthSamplePlayer_SetScrubTimeWidth Parms{};
|
|
|
|
Parms.InScrubTimeWidthSec = InScrubTimeWidthSec;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SynthSamplePlayer.SetSoundWave
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class USoundWave* InSoundWave (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void USynthSamplePlayer::SetSoundWave(class USoundWave* InSoundWave)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("SynthSamplePlayer", "SetSoundWave");
|
|
|
|
Params::SynthSamplePlayer_SetSoundWave Parms{};
|
|
|
|
Parms.InSoundWave = InSoundWave;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SynthSamplePlayer.GetCurrentPlaybackProgressPercent
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
float USynthSamplePlayer::GetCurrentPlaybackProgressPercent() const
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("SynthSamplePlayer", "GetCurrentPlaybackProgressPercent");
|
|
|
|
Params::SynthSamplePlayer_GetCurrentPlaybackProgressPercent Parms{};
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SynthSamplePlayer.GetCurrentPlaybackProgressTime
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
float USynthSamplePlayer::GetCurrentPlaybackProgressTime() const
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("SynthSamplePlayer", "GetCurrentPlaybackProgressTime");
|
|
|
|
Params::SynthSamplePlayer_GetCurrentPlaybackProgressTime Parms{};
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SynthSamplePlayer.GetSampleDuration
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
float USynthSamplePlayer::GetSampleDuration() const
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("SynthSamplePlayer", "GetSampleDuration");
|
|
|
|
Params::SynthSamplePlayer_GetSampleDuration Parms{};
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SynthSamplePlayer.IsLoaded
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
bool USynthSamplePlayer::IsLoaded() const
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("SynthSamplePlayer", "IsLoaded");
|
|
|
|
Params::SynthSamplePlayer_IsLoaded Parms{};
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SynthesisUtilitiesBlueprintFunctionLibrary.GetLinearFrequency
|
|
// (Final, Native, Static, Private, BlueprintCallable)
|
|
// Parameters:
|
|
// float InLogFrequencyValue (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float InDomainMin (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float InDomainMax (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float InRangeMin (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float InRangeMax (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
float USynthesisUtilitiesBlueprintFunctionLibrary::GetLinearFrequency(float InLogFrequencyValue, float InDomainMin, float InDomainMax, float InRangeMin, float InRangeMax)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = StaticClass()->GetFunction("SynthesisUtilitiesBlueprintFunctionLibrary", "GetLinearFrequency");
|
|
|
|
Params::SynthesisUtilitiesBlueprintFunctionLibrary_GetLinearFrequency Parms{};
|
|
|
|
Parms.InLogFrequencyValue = InLogFrequencyValue;
|
|
Parms.InDomainMin = InDomainMin;
|
|
Parms.InDomainMax = InDomainMax;
|
|
Parms.InRangeMin = InRangeMin;
|
|
Parms.InRangeMax = InRangeMax;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
GetDefaultObj()->ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SynthesisUtilitiesBlueprintFunctionLibrary.GetLogFrequency
|
|
// (Final, Native, Static, Private, BlueprintCallable)
|
|
// Parameters:
|
|
// float InLinearValue (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float InDomainMin (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float InDomainMax (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float InRangeMin (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float InRangeMax (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
float USynthesisUtilitiesBlueprintFunctionLibrary::GetLogFrequency(float InLinearValue, float InDomainMin, float InDomainMax, float InRangeMin, float InRangeMax)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = StaticClass()->GetFunction("SynthesisUtilitiesBlueprintFunctionLibrary", "GetLogFrequency");
|
|
|
|
Params::SynthesisUtilitiesBlueprintFunctionLibrary_GetLogFrequency Parms{};
|
|
|
|
Parms.InLinearValue = InLinearValue;
|
|
Parms.InDomainMin = InDomainMin;
|
|
Parms.InDomainMax = InDomainMax;
|
|
Parms.InRangeMin = InRangeMin;
|
|
Parms.InRangeMax = InRangeMax;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
GetDefaultObj()->ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Synthesis.Synth2DSlider.SetIndentHandle
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool InValue (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void USynth2DSlider::SetIndentHandle(bool InValue)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("Synth2DSlider", "SetIndentHandle");
|
|
|
|
Params::Synth2DSlider_SetIndentHandle Parms{};
|
|
|
|
Parms.InValue = InValue;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.Synth2DSlider.SetLocked
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool InValue (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void USynth2DSlider::SetLocked(bool InValue)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("Synth2DSlider", "SetLocked");
|
|
|
|
Params::Synth2DSlider_SetLocked Parms{};
|
|
|
|
Parms.InValue = InValue;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.Synth2DSlider.SetSliderHandleColor
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// const struct FLinearColor& InValue (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void USynth2DSlider::SetSliderHandleColor(const struct FLinearColor& InValue)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("Synth2DSlider", "SetSliderHandleColor");
|
|
|
|
Params::Synth2DSlider_SetSliderHandleColor Parms{};
|
|
|
|
Parms.InValue = std::move(InValue);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.Synth2DSlider.SetStepSize
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float InValue (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void USynth2DSlider::SetStepSize(float InValue)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("Synth2DSlider", "SetStepSize");
|
|
|
|
Params::Synth2DSlider_SetStepSize Parms{};
|
|
|
|
Parms.InValue = InValue;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.Synth2DSlider.SetValue
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// const struct FVector2D& InValue (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void USynth2DSlider::SetValue(const struct FVector2D& InValue)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("Synth2DSlider", "SetValue");
|
|
|
|
Params::Synth2DSlider_SetValue Parms{};
|
|
|
|
Parms.InValue = std::move(InValue);
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.Synth2DSlider.GetValue
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FVector2D ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
struct FVector2D USynth2DSlider::GetValue() const
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("Synth2DSlider", "GetValue");
|
|
|
|
Params::Synth2DSlider_GetValue Parms{};
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SynthKnob.SetLocked
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool InValue (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void USynthKnob::SetLocked(bool InValue)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("SynthKnob", "SetLocked");
|
|
|
|
Params::SynthKnob_SetLocked Parms{};
|
|
|
|
Parms.InValue = InValue;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SynthKnob.SetStepSize
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float InValue (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void USynthKnob::SetStepSize(float InValue)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("SynthKnob", "SetStepSize");
|
|
|
|
Params::SynthKnob_SetStepSize Parms{};
|
|
|
|
Parms.InValue = InValue;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SynthKnob.SetValue
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float InValue (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void USynthKnob::SetValue(float InValue)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("SynthKnob", "SetValue");
|
|
|
|
Params::SynthKnob_SetValue Parms{};
|
|
|
|
Parms.InValue = InValue;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
}
|
|
|
|
|
|
// Function Synthesis.SynthKnob.GetValue
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
float USynthKnob::GetValue() const
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (Func == nullptr)
|
|
Func = Class->GetFunction("SynthKnob", "GetValue");
|
|
|
|
Params::SynthKnob_GetValue Parms{};
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
}
|
|
|
|
|
|
SDK_NAMESPACE_END
|