forked from gcdsfh/PMDT
gcdsfh145
1756 lines
58 KiB
C++
Executable File
1756 lines
58 KiB
C++
Executable File
//PUBGM(0.13.5)32位SDK
|
|
//作者:清华
|
|
//Telegram:@qinghuanb666
|
|
//生成时间:Fri Apr 18 20:44:40 2025
|
|
|
|
#include "../SDK.hpp"
|
|
|
|
namespace SDK
|
|
{
|
|
//---------------------------------------------------------------------------
|
|
//Functions
|
|
//---------------------------------------------------------------------------
|
|
|
|
// Function AkAudio.AkAcousticPortal.OpenPortal
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
|
|
void AAkAcousticPortal::OpenPortal()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function AkAudio.AkAcousticPortal.OpenPortal");
|
|
|
|
AAkAcousticPortal_OpenPortal_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function AkAudio.AkAcousticPortal.GetCurrentState
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// EAkAcousticPortalState ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
EAkAcousticPortalState AAkAcousticPortal::GetCurrentState()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function AkAudio.AkAcousticPortal.GetCurrentState");
|
|
|
|
AAkAcousticPortal_GetCurrentState_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function AkAudio.AkAcousticPortal.ClosePortal
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
|
|
void AAkAcousticPortal::ClosePortal()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function AkAudio.AkAcousticPortal.ClosePortal");
|
|
|
|
AAkAcousticPortal_ClosePortal_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function AkAudio.AkAmbientSound.StopAmbientSound
|
|
// (Final, BlueprintCosmetic, Native, Public, BlueprintCallable)
|
|
|
|
void AAkAmbientSound::StopAmbientSound()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function AkAudio.AkAmbientSound.StopAmbientSound");
|
|
|
|
AAkAmbientSound_StopAmbientSound_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function AkAudio.AkAmbientSound.StartAmbientSound
|
|
// (Final, BlueprintCosmetic, Native, Public, BlueprintCallable)
|
|
|
|
void AAkAmbientSound::StartAmbientSound()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function AkAudio.AkAmbientSound.StartAmbientSound");
|
|
|
|
AAkAmbientSound_StartAmbientSound_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function AkAudio.AkComponent.UseReverbVolumes
|
|
// (Final, BlueprintCosmetic, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool inUseReverbVolumes (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UAkComponent::UseReverbVolumes(bool inUseReverbVolumes)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function AkAudio.AkComponent.UseReverbVolumes");
|
|
|
|
UAkComponent_UseReverbVolumes_Params params;
|
|
params.inUseReverbVolumes = inUseReverbVolumes;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function AkAudio.AkComponent.UseEarlyReflections
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UAkAuxBus* AuxBus (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool Left (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool Right (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool Floor (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool Ceiling (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool Back (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool Front (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool SpotReflectors (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FString AuxBusName (Parm, ZeroConstructor)
|
|
|
|
void UAkComponent::UseEarlyReflections(class UAkAuxBus* AuxBus, bool Left, bool Right, bool Floor, bool Ceiling, bool Back, bool Front, bool SpotReflectors, const struct FString& AuxBusName)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function AkAudio.AkComponent.UseEarlyReflections");
|
|
|
|
UAkComponent_UseEarlyReflections_Params params;
|
|
params.AuxBus = AuxBus;
|
|
params.Left = Left;
|
|
params.Right = Right;
|
|
params.Floor = Floor;
|
|
params.Ceiling = Ceiling;
|
|
params.Back = Back;
|
|
params.Front = Front;
|
|
params.SpotReflectors = SpotReflectors;
|
|
params.AuxBusName = AuxBusName;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function AkAudio.AkComponent.Stop
|
|
// (Final, BlueprintCosmetic, Native, Public, BlueprintCallable)
|
|
|
|
void UAkComponent::Stop()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function AkAudio.AkComponent.Stop");
|
|
|
|
UAkComponent_Stop_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function AkAudio.AkComponent.SetSwitch
|
|
// (Final, BlueprintCosmetic, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FString SwitchGroup (Parm, ZeroConstructor)
|
|
// struct FString SwitchState (Parm, ZeroConstructor)
|
|
|
|
void UAkComponent::SetSwitch(const struct FString& SwitchGroup, const struct FString& SwitchState)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function AkAudio.AkComponent.SetSwitch");
|
|
|
|
UAkComponent_SetSwitch_Params params;
|
|
params.SwitchGroup = SwitchGroup;
|
|
params.SwitchState = SwitchState;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function AkAudio.AkComponent.SetStopWhenOwnerDestroyed
|
|
// (Final, BlueprintCosmetic, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bStopWhenOwnerDestroyed (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UAkComponent::SetStopWhenOwnerDestroyed(bool bStopWhenOwnerDestroyed)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function AkAudio.AkComponent.SetStopWhenOwnerDestroyed");
|
|
|
|
UAkComponent_SetStopWhenOwnerDestroyed_Params params;
|
|
params.bStopWhenOwnerDestroyed = bStopWhenOwnerDestroyed;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function AkAudio.AkComponent.SetRTPCValueGlobally
|
|
// (Final, BlueprintCosmetic, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FString RTPC (Parm, ZeroConstructor)
|
|
// float Value (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UAkComponent::SetRTPCValueGlobally(const struct FString& RTPC, float Value)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function AkAudio.AkComponent.SetRTPCValueGlobally");
|
|
|
|
UAkComponent_SetRTPCValueGlobally_Params params;
|
|
params.RTPC = RTPC;
|
|
params.Value = Value;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function AkAudio.AkComponent.SetRTPCValue
|
|
// (Final, BlueprintCosmetic, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FString RTPC (Parm, ZeroConstructor)
|
|
// float Value (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int InterpolationTimeMs (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UAkComponent::SetRTPCValue(const struct FString& RTPC, float Value, int InterpolationTimeMs)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function AkAudio.AkComponent.SetRTPCValue");
|
|
|
|
UAkComponent_SetRTPCValue_Params params;
|
|
params.RTPC = RTPC;
|
|
params.Value = Value;
|
|
params.InterpolationTimeMs = InterpolationTimeMs;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function AkAudio.AkComponent.SetOutputBusVolume
|
|
// (Final, BlueprintCosmetic, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float BusVolume (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UAkComponent::SetOutputBusVolume(float BusVolume)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function AkAudio.AkComponent.SetOutputBusVolume");
|
|
|
|
UAkComponent_SetOutputBusVolume_Params params;
|
|
params.BusVolume = BusVolume;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function AkAudio.AkComponent.SetListeners
|
|
// (Final, BlueprintCosmetic, Native, Public, HasOutParms, BlueprintCallable)
|
|
// Parameters:
|
|
// TArray<class UAkComponent*> Listeners (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
|
|
|
|
void UAkComponent::SetListeners(TArray<class UAkComponent*> Listeners)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function AkAudio.AkComponent.SetListeners");
|
|
|
|
UAkComponent_SetListeners_Params params;
|
|
params.Listeners = Listeners;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function AkAudio.AkComponent.SetEarlyReflectionOrder
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// int NewEarlyReflectionOrder (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UAkComponent::SetEarlyReflectionOrder(int NewEarlyReflectionOrder)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function AkAudio.AkComponent.SetEarlyReflectionOrder");
|
|
|
|
UAkComponent_SetEarlyReflectionOrder_Params params;
|
|
params.NewEarlyReflectionOrder = NewEarlyReflectionOrder;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function AkAudio.AkComponent.SetAutoDestroy
|
|
// (Final, BlueprintCosmetic, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool in_AutoDestroy (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UAkComponent::SetAutoDestroy(bool in_AutoDestroy)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function AkAudio.AkComponent.SetAutoDestroy");
|
|
|
|
UAkComponent_SetAutoDestroy_Params params;
|
|
params.in_AutoDestroy = in_AutoDestroy;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function AkAudio.AkComponent.SetAttenuationScalingFactor
|
|
// (Final, BlueprintCosmetic, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float Value (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UAkComponent::SetAttenuationScalingFactor(float Value)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function AkAudio.AkComponent.SetAttenuationScalingFactor");
|
|
|
|
UAkComponent_SetAttenuationScalingFactor_Params params;
|
|
params.Value = Value;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function AkAudio.AkComponent.PostTrigger
|
|
// (Final, BlueprintCosmetic, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FString Trigger (Parm, ZeroConstructor)
|
|
|
|
void UAkComponent::PostTrigger(const struct FString& Trigger)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function AkAudio.AkComponent.PostTrigger");
|
|
|
|
UAkComponent_PostTrigger_Params params;
|
|
params.Trigger = Trigger;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function AkAudio.AkComponent.PostAssociatedAkEvent
|
|
// (Final, BlueprintCosmetic, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// int ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
int UAkComponent::PostAssociatedAkEvent()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function AkAudio.AkComponent.PostAssociatedAkEvent");
|
|
|
|
UAkComponent_PostAssociatedAkEvent_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function AkAudio.AkComponent.PostAkEventByName
|
|
// (Final, BlueprintCosmetic, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FString in_EventName (Parm, ZeroConstructor)
|
|
// int ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
int UAkComponent::PostAkEventByName(const struct FString& in_EventName)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function AkAudio.AkComponent.PostAkEventByName");
|
|
|
|
UAkComponent_PostAkEventByName_Params params;
|
|
params.in_EventName = in_EventName;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function AkAudio.AkComponent.PostAkEvent
|
|
// (Final, BlueprintCosmetic, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UAkAudioEvent* AkEvent (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FString in_EventName (Parm, ZeroConstructor)
|
|
// int ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
int UAkComponent::PostAkEvent(class UAkAudioEvent* AkEvent, const struct FString& in_EventName)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function AkAudio.AkComponent.PostAkEvent");
|
|
|
|
UAkComponent_PostAkEvent_Params params;
|
|
params.AkEvent = AkEvent;
|
|
params.in_EventName = in_EventName;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function AkAudio.AkComponent.GetAttenuationRadius
|
|
// (Final, BlueprintCosmetic, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UAkComponent::GetAttenuationRadius()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function AkAudio.AkComponent.GetAttenuationRadius");
|
|
|
|
UAkComponent_GetAttenuationRadius_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function AkAudio.AkGameplayStatics.WakeupFromSuspend
|
|
// (Final, BlueprintCosmetic, Native, Static, Public, BlueprintCallable)
|
|
|
|
void UAkGameplayStatics::WakeupFromSuspend()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function AkAudio.AkGameplayStatics.WakeupFromSuspend");
|
|
|
|
UAkGameplayStatics_WakeupFromSuspend_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function AkAudio.AkGameplayStatics.UseReverbVolumes
|
|
// (Final, BlueprintCosmetic, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool inUseReverbVolumes (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class AActor* Actor (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UAkGameplayStatics::UseReverbVolumes(bool inUseReverbVolumes, class AActor* Actor)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function AkAudio.AkGameplayStatics.UseReverbVolumes");
|
|
|
|
UAkGameplayStatics_UseReverbVolumes_Params params;
|
|
params.inUseReverbVolumes = inUseReverbVolumes;
|
|
params.Actor = Actor;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function AkAudio.AkGameplayStatics.UseEarlyReflections
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class AActor* Actor (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UAkAuxBus* AuxBus (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool Left (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool Right (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool Floor (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool Ceiling (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool Back (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool Front (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool SpotReflectors (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FString AuxBusName (Parm, ZeroConstructor)
|
|
|
|
void UAkGameplayStatics::UseEarlyReflections(class AActor* Actor, class UAkAuxBus* AuxBus, bool Left, bool Right, bool Floor, bool Ceiling, bool Back, bool Front, bool SpotReflectors, const struct FString& AuxBusName)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function AkAudio.AkGameplayStatics.UseEarlyReflections");
|
|
|
|
UAkGameplayStatics_UseEarlyReflections_Params params;
|
|
params.Actor = Actor;
|
|
params.AuxBus = AuxBus;
|
|
params.Left = Left;
|
|
params.Right = Right;
|
|
params.Floor = Floor;
|
|
params.Ceiling = Ceiling;
|
|
params.Back = Back;
|
|
params.Front = Front;
|
|
params.SpotReflectors = SpotReflectors;
|
|
params.AuxBusName = AuxBusName;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function AkAudio.AkGameplayStatics.UnloadBankByName
|
|
// (Final, BlueprintCosmetic, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FString BankName (Parm, ZeroConstructor)
|
|
|
|
void UAkGameplayStatics::UnloadBankByName(const struct FString& BankName)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function AkAudio.AkGameplayStatics.UnloadBankByName");
|
|
|
|
UAkGameplayStatics_UnloadBankByName_Params params;
|
|
params.BankName = BankName;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function AkAudio.AkGameplayStatics.UnloadBank
|
|
// (Final, BlueprintCosmetic, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UAkAudioBank* Bank (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FString BankName (Parm, ZeroConstructor)
|
|
|
|
void UAkGameplayStatics::UnloadBank(class UAkAudioBank* Bank, const struct FString& BankName)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function AkAudio.AkGameplayStatics.UnloadBank");
|
|
|
|
UAkGameplayStatics_UnloadBank_Params params;
|
|
params.Bank = Bank;
|
|
params.BankName = BankName;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function AkAudio.AkGameplayStatics.Suspend
|
|
// (Final, BlueprintCosmetic, Native, Static, Public, BlueprintCallable)
|
|
|
|
void UAkGameplayStatics::Suspend()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function AkAudio.AkGameplayStatics.Suspend");
|
|
|
|
UAkGameplayStatics_Suspend_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function AkAudio.AkGameplayStatics.StopProfilerCapture
|
|
// (Final, BlueprintCosmetic, Native, Static, Public, BlueprintCallable)
|
|
|
|
void UAkGameplayStatics::StopProfilerCapture()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function AkAudio.AkGameplayStatics.StopProfilerCapture");
|
|
|
|
UAkGameplayStatics_StopProfilerCapture_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function AkAudio.AkGameplayStatics.StopOutputCapture
|
|
// (Final, BlueprintCosmetic, Native, Static, Public, BlueprintCallable)
|
|
|
|
void UAkGameplayStatics::StopOutputCapture()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function AkAudio.AkGameplayStatics.StopOutputCapture");
|
|
|
|
UAkGameplayStatics_StopOutputCapture_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function AkAudio.AkGameplayStatics.StopAllAmbientSounds
|
|
// (Final, BlueprintCosmetic, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UAkGameplayStatics::StopAllAmbientSounds(class UObject* WorldContextObject)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function AkAudio.AkGameplayStatics.StopAllAmbientSounds");
|
|
|
|
UAkGameplayStatics_StopAllAmbientSounds_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function AkAudio.AkGameplayStatics.StopAll
|
|
// (Final, BlueprintCosmetic, Native, Static, Public, BlueprintCallable)
|
|
|
|
void UAkGameplayStatics::StopAll()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function AkAudio.AkGameplayStatics.StopAll");
|
|
|
|
UAkGameplayStatics_StopAll_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function AkAudio.AkGameplayStatics.StopActor
|
|
// (Final, BlueprintCosmetic, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class AActor* Actor (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UAkGameplayStatics::StopActor(class AActor* Actor)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function AkAudio.AkGameplayStatics.StopActor");
|
|
|
|
UAkGameplayStatics_StopActor_Params params;
|
|
params.Actor = Actor;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function AkAudio.AkGameplayStatics.StartProfilerCapture
|
|
// (Final, BlueprintCosmetic, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FString Filename (Parm, ZeroConstructor)
|
|
|
|
void UAkGameplayStatics::StartProfilerCapture(const struct FString& Filename)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function AkAudio.AkGameplayStatics.StartProfilerCapture");
|
|
|
|
UAkGameplayStatics_StartProfilerCapture_Params params;
|
|
params.Filename = Filename;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function AkAudio.AkGameplayStatics.StartOutputCapture
|
|
// (Final, BlueprintCosmetic, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FString Filename (Parm, ZeroConstructor)
|
|
|
|
void UAkGameplayStatics::StartOutputCapture(const struct FString& Filename)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function AkAudio.AkGameplayStatics.StartOutputCapture");
|
|
|
|
UAkGameplayStatics_StartOutputCapture_Params params;
|
|
params.Filename = Filename;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function AkAudio.AkGameplayStatics.StartAllAmbientSounds
|
|
// (Final, BlueprintCosmetic, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UAkGameplayStatics::StartAllAmbientSounds(class UObject* WorldContextObject)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function AkAudio.AkGameplayStatics.StartAllAmbientSounds");
|
|
|
|
UAkGameplayStatics_StartAllAmbientSounds_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function AkAudio.AkGameplayStatics.SpawnAkComponentAtLocation
|
|
// (Final, BlueprintCosmetic, Native, Static, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UAkAudioEvent* AkEvent (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UAkAuxBus* EarlyReflectionsBus (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector Location (Parm, IsPlainOldData)
|
|
// struct FRotator Orientation (Parm, IsPlainOldData)
|
|
// bool AutoPost (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FString EventName (Parm, ZeroConstructor)
|
|
// struct FString EarlyReflectionsBusName (Parm, ZeroConstructor)
|
|
// bool AutoDestroy (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UAkComponent* ReturnValue (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData)
|
|
|
|
class UAkComponent* UAkGameplayStatics::SpawnAkComponentAtLocation(class UObject* WorldContextObject, class UAkAudioEvent* AkEvent, class UAkAuxBus* EarlyReflectionsBus, const struct FVector& Location, const struct FRotator& Orientation, bool AutoPost, const struct FString& EventName, const struct FString& EarlyReflectionsBusName, bool AutoDestroy)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function AkAudio.AkGameplayStatics.SpawnAkComponentAtLocation");
|
|
|
|
UAkGameplayStatics_SpawnAkComponentAtLocation_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.AkEvent = AkEvent;
|
|
params.EarlyReflectionsBus = EarlyReflectionsBus;
|
|
params.Location = Location;
|
|
params.Orientation = Orientation;
|
|
params.AutoPost = AutoPost;
|
|
params.EventName = EventName;
|
|
params.EarlyReflectionsBusName = EarlyReflectionsBusName;
|
|
params.AutoDestroy = AutoDestroy;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function AkAudio.AkGameplayStatics.ShowAKComponentPosition
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool _IsShow (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UAkGameplayStatics::ShowAKComponentPosition(bool _IsShow)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function AkAudio.AkGameplayStatics.ShowAKComponentPosition");
|
|
|
|
UAkGameplayStatics_ShowAKComponentPosition_Params params;
|
|
params._IsShow = _IsShow;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function AkAudio.AkGameplayStatics.SetSwitch
|
|
// (Final, BlueprintCosmetic, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FName SwitchGroup (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FName SwitchState (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class AActor* Actor (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UAkGameplayStatics::SetSwitch(const struct FName& SwitchGroup, const struct FName& SwitchState, class AActor* Actor)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function AkAudio.AkGameplayStatics.SetSwitch");
|
|
|
|
UAkGameplayStatics_SetSwitch_Params params;
|
|
params.SwitchGroup = SwitchGroup;
|
|
params.SwitchState = SwitchState;
|
|
params.Actor = Actor;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function AkAudio.AkGameplayStatics.SetState
|
|
// (Final, BlueprintCosmetic, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FName StateGroup (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FName State (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UAkGameplayStatics::SetState(const struct FName& StateGroup, const struct FName& State)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function AkAudio.AkGameplayStatics.SetState");
|
|
|
|
UAkGameplayStatics_SetState_Params params;
|
|
params.StateGroup = StateGroup;
|
|
params.State = State;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function AkAudio.AkGameplayStatics.SetRTPCValue
|
|
// (Final, BlueprintCosmetic, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FName RTPC (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float Value (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int InterpolationTimeMs (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class AActor* Actor (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UAkGameplayStatics::SetRTPCValue(const struct FName& RTPC, float Value, int InterpolationTimeMs, class AActor* Actor)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function AkAudio.AkGameplayStatics.SetRTPCValue");
|
|
|
|
UAkGameplayStatics_SetRTPCValue_Params params;
|
|
params.RTPC = RTPC;
|
|
params.Value = Value;
|
|
params.InterpolationTimeMs = InterpolationTimeMs;
|
|
params.Actor = Actor;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function AkAudio.AkGameplayStatics.SetPanningRule
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// EPanningRule PanRule (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UAkGameplayStatics::SetPanningRule(EPanningRule PanRule)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function AkAudio.AkGameplayStatics.SetPanningRule");
|
|
|
|
UAkGameplayStatics_SetPanningRule_Params params;
|
|
params.PanRule = PanRule;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function AkAudio.AkGameplayStatics.SetOutputBusVolume
|
|
// (Final, BlueprintCosmetic, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float BusVolume (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class AActor* Actor (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UAkGameplayStatics::SetOutputBusVolume(float BusVolume, class AActor* Actor)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function AkAudio.AkGameplayStatics.SetOutputBusVolume");
|
|
|
|
UAkGameplayStatics_SetOutputBusVolume_Params params;
|
|
params.BusVolume = BusVolume;
|
|
params.Actor = Actor;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function AkAudio.AkGameplayStatics.SetOcclusionScalingFactor
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float ScalingFactor (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UAkGameplayStatics::SetOcclusionScalingFactor(float ScalingFactor)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function AkAudio.AkGameplayStatics.SetOcclusionScalingFactor");
|
|
|
|
UAkGameplayStatics_SetOcclusionScalingFactor_Params params;
|
|
params.ScalingFactor = ScalingFactor;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function AkAudio.AkGameplayStatics.SetOcclusionRefreshInterval
|
|
// (Final, BlueprintCosmetic, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float RefreshInterval (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class AActor* Actor (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UAkGameplayStatics::SetOcclusionRefreshInterval(float RefreshInterval, class AActor* Actor)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function AkAudio.AkGameplayStatics.SetOcclusionRefreshInterval");
|
|
|
|
UAkGameplayStatics_SetOcclusionRefreshInterval_Params params;
|
|
params.RefreshInterval = RefreshInterval;
|
|
params.Actor = Actor;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function AkAudio.AkGameplayStatics.SetBusConfig
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FString BusName (Parm, ZeroConstructor)
|
|
// EAkChannelConfiguration ChannelConfiguration (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UAkGameplayStatics::SetBusConfig(const struct FString& BusName, EAkChannelConfiguration ChannelConfiguration)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function AkAudio.AkGameplayStatics.SetBusConfig");
|
|
|
|
UAkGameplayStatics_SetBusConfig_Params params;
|
|
params.BusName = BusName;
|
|
params.ChannelConfiguration = ChannelConfiguration;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function AkAudio.AkGameplayStatics.PostTrigger
|
|
// (Final, BlueprintCosmetic, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FName Trigger (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class AActor* Actor (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UAkGameplayStatics::PostTrigger(const struct FName& Trigger, class AActor* Actor)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function AkAudio.AkGameplayStatics.PostTrigger");
|
|
|
|
UAkGameplayStatics_PostTrigger_Params params;
|
|
params.Trigger = Trigger;
|
|
params.Actor = Actor;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function AkAudio.AkGameplayStatics.PostEventByName
|
|
// (Final, BlueprintCosmetic, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FString EventName (Parm, ZeroConstructor)
|
|
// class AActor* Actor (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bStopWhenAttachedToDestroyed (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UAkGameplayStatics::PostEventByName(const struct FString& EventName, class AActor* Actor, bool bStopWhenAttachedToDestroyed)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function AkAudio.AkGameplayStatics.PostEventByName");
|
|
|
|
UAkGameplayStatics_PostEventByName_Params params;
|
|
params.EventName = EventName;
|
|
params.Actor = Actor;
|
|
params.bStopWhenAttachedToDestroyed = bStopWhenAttachedToDestroyed;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function AkAudio.AkGameplayStatics.PostEventAttached
|
|
// (Final, BlueprintCosmetic, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UAkAudioEvent* AkEvent (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class AActor* Actor (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FName AttachPointName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bStopWhenAttachedToDestroyed (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FString EventName (Parm, ZeroConstructor)
|
|
// int ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
int UAkGameplayStatics::PostEventAttached(class UAkAudioEvent* AkEvent, class AActor* Actor, const struct FName& AttachPointName, bool bStopWhenAttachedToDestroyed, const struct FString& EventName)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function AkAudio.AkGameplayStatics.PostEventAttached");
|
|
|
|
UAkGameplayStatics_PostEventAttached_Params params;
|
|
params.AkEvent = AkEvent;
|
|
params.Actor = Actor;
|
|
params.AttachPointName = AttachPointName;
|
|
params.bStopWhenAttachedToDestroyed = bStopWhenAttachedToDestroyed;
|
|
params.EventName = EventName;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function AkAudio.AkGameplayStatics.PostEventAtLocationByName
|
|
// (Final, BlueprintCosmetic, Native, Static, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FString EventName (Parm, ZeroConstructor)
|
|
// struct FVector Location (Parm, IsPlainOldData)
|
|
// struct FRotator Orientation (Parm, IsPlainOldData)
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UAkGameplayStatics::PostEventAtLocationByName(const struct FString& EventName, const struct FVector& Location, const struct FRotator& Orientation, class UObject* WorldContextObject)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function AkAudio.AkGameplayStatics.PostEventAtLocationByName");
|
|
|
|
UAkGameplayStatics_PostEventAtLocationByName_Params params;
|
|
params.EventName = EventName;
|
|
params.Location = Location;
|
|
params.Orientation = Orientation;
|
|
params.WorldContextObject = WorldContextObject;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function AkAudio.AkGameplayStatics.PostEventAtLocation
|
|
// (Final, BlueprintCosmetic, Native, Static, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// class UAkAudioEvent* AkEvent (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector Location (Parm, IsPlainOldData)
|
|
// struct FRotator Orientation (Parm, IsPlainOldData)
|
|
// struct FString EventName (Parm, ZeroConstructor)
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
int UAkGameplayStatics::PostEventAtLocation(class UAkAudioEvent* AkEvent, const struct FVector& Location, const struct FRotator& Orientation, const struct FString& EventName, class UObject* WorldContextObject)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function AkAudio.AkGameplayStatics.PostEventAtLocation");
|
|
|
|
UAkGameplayStatics_PostEventAtLocation_Params params;
|
|
params.AkEvent = AkEvent;
|
|
params.Location = Location;
|
|
params.Orientation = Orientation;
|
|
params.EventName = EventName;
|
|
params.WorldContextObject = WorldContextObject;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function AkAudio.AkGameplayStatics.PostEvent
|
|
// (Final, BlueprintCosmetic, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UAkAudioEvent* AkEvent (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class AActor* Actor (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bStopWhenAttachedToDestroyed (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FString EventName (Parm, ZeroConstructor)
|
|
// int ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
int UAkGameplayStatics::PostEvent(class UAkAudioEvent* AkEvent, class AActor* Actor, bool bStopWhenAttachedToDestroyed, const struct FString& EventName)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function AkAudio.AkGameplayStatics.PostEvent");
|
|
|
|
UAkGameplayStatics_PostEvent_Params params;
|
|
params.AkEvent = AkEvent;
|
|
params.Actor = Actor;
|
|
params.bStopWhenAttachedToDestroyed = bStopWhenAttachedToDestroyed;
|
|
params.EventName = EventName;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function AkAudio.AkGameplayStatics.LoadInitBank
|
|
// (Final, BlueprintCosmetic, Native, Static, Public, BlueprintCallable)
|
|
|
|
void UAkGameplayStatics::LoadInitBank()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function AkAudio.AkGameplayStatics.LoadInitBank");
|
|
|
|
UAkGameplayStatics_LoadInitBank_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function AkAudio.AkGameplayStatics.LoadBanks
|
|
// (Final, BlueprintCosmetic, Native, Static, Public, HasOutParms, BlueprintCallable)
|
|
// Parameters:
|
|
// TArray<class UAkAudioBank*> SoundBanks (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
|
|
// bool SynchronizeSoundBanks (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UAkGameplayStatics::LoadBanks(TArray<class UAkAudioBank*> SoundBanks, bool SynchronizeSoundBanks)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function AkAudio.AkGameplayStatics.LoadBanks");
|
|
|
|
UAkGameplayStatics_LoadBanks_Params params;
|
|
params.SoundBanks = SoundBanks;
|
|
params.SynchronizeSoundBanks = SynchronizeSoundBanks;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function AkAudio.AkGameplayStatics.LoadBankByName
|
|
// (Final, BlueprintCosmetic, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FString BankName (Parm, ZeroConstructor)
|
|
|
|
void UAkGameplayStatics::LoadBankByName(const struct FString& BankName)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function AkAudio.AkGameplayStatics.LoadBankByName");
|
|
|
|
UAkGameplayStatics_LoadBankByName_Params params;
|
|
params.BankName = BankName;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function AkAudio.AkGameplayStatics.LoadBank
|
|
// (Final, BlueprintCosmetic, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UAkAudioBank* Bank (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FString BankName (Parm, ZeroConstructor)
|
|
|
|
void UAkGameplayStatics::LoadBank(class UAkAudioBank* Bank, const struct FString& BankName)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function AkAudio.AkGameplayStatics.LoadBank");
|
|
|
|
UAkGameplayStatics_LoadBank_Params params;
|
|
params.Bank = Bank;
|
|
params.BankName = BankName;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function AkAudio.AkGameplayStatics.IsGame
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UAkGameplayStatics::IsGame(class UObject* WorldContextObject)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function AkAudio.AkGameplayStatics.IsGame");
|
|
|
|
UAkGameplayStatics_IsGame_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function AkAudio.AkGameplayStatics.IsEditor
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UAkGameplayStatics::IsEditor()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function AkAudio.AkGameplayStatics.IsEditor");
|
|
|
|
UAkGameplayStatics_IsEditor_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function AkAudio.AkGameplayStatics.GetOcclusionScalingFactor
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UAkGameplayStatics::GetOcclusionScalingFactor()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function AkAudio.AkGameplayStatics.GetOcclusionScalingFactor");
|
|
|
|
UAkGameplayStatics_GetOcclusionScalingFactor_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function AkAudio.AkGameplayStatics.GetAkComponent
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// class USceneComponent* AttachToComponent (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
|
|
// struct FName AttachPointName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector Location (Parm, IsPlainOldData)
|
|
// TEnumAsByte<EAttachLocation> LocationType (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UAkComponent* ReturnValue (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData)
|
|
|
|
class UAkComponent* UAkGameplayStatics::GetAkComponent(class USceneComponent* AttachToComponent, const struct FName& AttachPointName, const struct FVector& Location, TEnumAsByte<EAttachLocation> LocationType)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function AkAudio.AkGameplayStatics.GetAkComponent");
|
|
|
|
UAkGameplayStatics_GetAkComponent_Params params;
|
|
params.AttachToComponent = AttachToComponent;
|
|
params.AttachPointName = AttachPointName;
|
|
params.Location = Location;
|
|
params.LocationType = LocationType;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function AkAudio.AkGameplayStatics.ClearBanks
|
|
// (Final, BlueprintCosmetic, Native, Static, Public, BlueprintCallable)
|
|
|
|
void UAkGameplayStatics::ClearBanks()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function AkAudio.AkGameplayStatics.ClearBanks");
|
|
|
|
UAkGameplayStatics_ClearBanks_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function AkAudio.AkGameplayStatics.AKSetRTPCValue
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FString RTPC (Parm, ZeroConstructor)
|
|
// float Value (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool in_bBypassInternalValueInterpolation (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UAkGameplayStatics::AKSetRTPCValue(const struct FString& RTPC, float Value, bool in_bBypassInternalValueInterpolation)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function AkAudio.AkGameplayStatics.AKSetRTPCValue");
|
|
|
|
UAkGameplayStatics_AKSetRTPCValue_Params params;
|
|
params.RTPC = RTPC;
|
|
params.Value = Value;
|
|
params.in_bBypassInternalValueInterpolation = in_bBypassInternalValueInterpolation;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function AkAudio.AkGameplayStatics.AddOutputCaptureMarker
|
|
// (Final, BlueprintCosmetic, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FString MarkerText (Parm, ZeroConstructor)
|
|
|
|
void UAkGameplayStatics::AddOutputCaptureMarker(const struct FString& MarkerText)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function AkAudio.AkGameplayStatics.AddOutputCaptureMarker");
|
|
|
|
UAkGameplayStatics_AddOutputCaptureMarker_Params params;
|
|
params.MarkerText = MarkerText;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function AkAudio.AkRoomComponent.RemoveSpatialAudioRoom
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
|
|
void UAkRoomComponent::RemoveSpatialAudioRoom()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function AkAudio.AkRoomComponent.RemoveSpatialAudioRoom");
|
|
|
|
UAkRoomComponent_RemoveSpatialAudioRoom_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function AkAudio.AkRoomComponent.AddSpatialAudioRoom
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
|
|
void UAkRoomComponent::AddSpatialAudioRoom()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function AkAudio.AkRoomComponent.AddSpatialAudioRoom");
|
|
|
|
UAkRoomComponent_AddSpatialAudioRoom_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function AkAudio.AkSurfaceReflectorSetComponent.UpdateSurfaceReflectorSet
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
|
|
void UAkSurfaceReflectorSetComponent::UpdateSurfaceReflectorSet()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function AkAudio.AkSurfaceReflectorSetComponent.UpdateSurfaceReflectorSet");
|
|
|
|
UAkSurfaceReflectorSetComponent_UpdateSurfaceReflectorSet_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function AkAudio.AkSurfaceReflectorSetComponent.SendSurfaceReflectorSet
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
|
|
void UAkSurfaceReflectorSetComponent::SendSurfaceReflectorSet()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function AkAudio.AkSurfaceReflectorSetComponent.SendSurfaceReflectorSet");
|
|
|
|
UAkSurfaceReflectorSetComponent_SendSurfaceReflectorSet_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function AkAudio.AkSurfaceReflectorSetComponent.RemoveSurfaceReflectorSet
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
|
|
void UAkSurfaceReflectorSetComponent::RemoveSurfaceReflectorSet()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function AkAudio.AkSurfaceReflectorSetComponent.RemoveSurfaceReflectorSet");
|
|
|
|
UAkSurfaceReflectorSetComponent_RemoveSurfaceReflectorSet_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
}
|
|
|