#pragma once // Dumped with Dumper-7! #include "../SDK.hpp" namespace SDK { //--------------------------------------------------------------------------------------------------------------------- // FUNCTIONS //--------------------------------------------------------------------------------------------------------------------- // Class SequencerScripting.MovieSceneScriptingKey // (None) class UClass* UMovieSceneScriptingKey::StaticClass() { static class UClass* Clss = nullptr; if (!Clss) Clss = UObject::FindClassFast("MovieSceneScriptingKey"); return Clss; } // MovieSceneScriptingKey SequencerScripting.Default__MovieSceneScriptingKey // (Public, ClassDefaultObject, ArchetypeObject) class UMovieSceneScriptingKey* UMovieSceneScriptingKey::GetDefaultObj() { static class UMovieSceneScriptingKey* Default = nullptr; if (!Default) Default = static_cast(UMovieSceneScriptingKey::StaticClass()->DefaultObject); return Default; } // Class SequencerScripting.MovieSceneScriptingActorReferenceKey // (None) class UClass* UMovieSceneScriptingActorReferenceKey::StaticClass() { static class UClass* Clss = nullptr; if (!Clss) Clss = UObject::FindClassFast("MovieSceneScriptingActorReferenceKey"); return Clss; } // MovieSceneScriptingActorReferenceKey SequencerScripting.Default__MovieSceneScriptingActorReferenceKey // (Public, ClassDefaultObject, ArchetypeObject) class UMovieSceneScriptingActorReferenceKey* UMovieSceneScriptingActorReferenceKey::GetDefaultObj() { static class UMovieSceneScriptingActorReferenceKey* Default = nullptr; if (!Default) Default = static_cast(UMovieSceneScriptingActorReferenceKey::StaticClass()->DefaultObject); return Default; } // Function SequencerScripting.MovieSceneScriptingActorReferenceKey.SetValue // (Final, Native, Public, HasOutParams, BlueprintCallable) // Parameters: // struct FMovieSceneObjectBindingID InNewValue (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) void UMovieSceneScriptingActorReferenceKey::SetValue(struct FMovieSceneObjectBindingID& InNewValue) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingActorReferenceKey", "SetValue"); Params::UMovieSceneScriptingActorReferenceKey_SetValue_Params Parms{}; Parms.InNewValue = InNewValue; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; } // Function SequencerScripting.MovieSceneScriptingActorReferenceKey.SetTime // (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable) // Parameters: // struct FFrameNumber NewFrameNumber (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // float SubFrame (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // enum class ESequenceTimeUnit TimeUnit (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) void UMovieSceneScriptingActorReferenceKey::SetTime(struct FFrameNumber& NewFrameNumber, float SubFrame, enum class ESequenceTimeUnit TimeUnit) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingActorReferenceKey", "SetTime"); Params::UMovieSceneScriptingActorReferenceKey_SetTime_Params Parms{}; Parms.NewFrameNumber = NewFrameNumber; Parms.SubFrame = SubFrame; Parms.TimeUnit = TimeUnit; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; } // Function SequencerScripting.MovieSceneScriptingActorReferenceKey.GetValue // (Final, Native, Public, BlueprintCallable, BlueprintPure, Const) // Parameters: // struct FMovieSceneObjectBindingID ReturnValue (Parm, OutParm, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) struct FMovieSceneObjectBindingID UMovieSceneScriptingActorReferenceKey::GetValue() { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingActorReferenceKey", "GetValue"); Params::UMovieSceneScriptingActorReferenceKey_GetValue_Params Parms{}; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneScriptingActorReferenceKey.GetTime // (Native, Public, BlueprintCallable, BlueprintPure, Const) // Parameters: // enum class ESequenceTimeUnit TimeUnit (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // struct FFrameTime ReturnValue (Parm, OutParm, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) struct FFrameTime UMovieSceneScriptingActorReferenceKey::GetTime(enum class ESequenceTimeUnit TimeUnit) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingActorReferenceKey", "GetTime"); Params::UMovieSceneScriptingActorReferenceKey_GetTime_Params Parms{}; Parms.TimeUnit = TimeUnit; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Class SequencerScripting.MovieSceneScriptingChannel // (None) class UClass* UMovieSceneScriptingChannel::StaticClass() { static class UClass* Clss = nullptr; if (!Clss) Clss = UObject::FindClassFast("MovieSceneScriptingChannel"); return Clss; } // MovieSceneScriptingChannel SequencerScripting.Default__MovieSceneScriptingChannel // (Public, ClassDefaultObject, ArchetypeObject) class UMovieSceneScriptingChannel* UMovieSceneScriptingChannel::GetDefaultObj() { static class UMovieSceneScriptingChannel* Default = nullptr; if (!Default) Default = static_cast(UMovieSceneScriptingChannel::StaticClass()->DefaultObject); return Default; } // Class SequencerScripting.MovieSceneScriptingActorReferenceChannel // (None) class UClass* UMovieSceneScriptingActorReferenceChannel::StaticClass() { static class UClass* Clss = nullptr; if (!Clss) Clss = UObject::FindClassFast("MovieSceneScriptingActorReferenceChannel"); return Clss; } // MovieSceneScriptingActorReferenceChannel SequencerScripting.Default__MovieSceneScriptingActorReferenceChannel // (Public, ClassDefaultObject, ArchetypeObject) class UMovieSceneScriptingActorReferenceChannel* UMovieSceneScriptingActorReferenceChannel::GetDefaultObj() { static class UMovieSceneScriptingActorReferenceChannel* Default = nullptr; if (!Default) Default = static_cast(UMovieSceneScriptingActorReferenceChannel::StaticClass()->DefaultObject); return Default; } // Function SequencerScripting.MovieSceneScriptingActorReferenceChannel.SetDefault // (Final, Native, Public, BlueprintCallable) // Parameters: // struct FMovieSceneObjectBindingID InDefaultValue (Parm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) void UMovieSceneScriptingActorReferenceChannel::SetDefault(const struct FMovieSceneObjectBindingID& InDefaultValue) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingActorReferenceChannel", "SetDefault"); Params::UMovieSceneScriptingActorReferenceChannel_SetDefault_Params Parms{}; Parms.InDefaultValue = InDefaultValue; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; } // Function SequencerScripting.MovieSceneScriptingActorReferenceChannel.RemoveKey // (Native, Public, BlueprintCallable) // Parameters: // class UMovieSceneScriptingKey* Key (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) void UMovieSceneScriptingActorReferenceChannel::RemoveKey(class UMovieSceneScriptingKey* Key) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingActorReferenceChannel", "RemoveKey"); Params::UMovieSceneScriptingActorReferenceChannel_RemoveKey_Params Parms{}; Parms.Key = Key; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; } // Function SequencerScripting.MovieSceneScriptingActorReferenceChannel.RemoveDefault // (Final, Native, Public, BlueprintCallable) // Parameters: void UMovieSceneScriptingActorReferenceChannel::RemoveDefault() { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingActorReferenceChannel", "RemoveDefault"); auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, nullptr); Func->FunctionFlags = Flgs; } // Function SequencerScripting.MovieSceneScriptingActorReferenceChannel.HasDefault // (Final, Native, Public, BlueprintCallable, BlueprintPure, Const) // Parameters: // bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) bool UMovieSceneScriptingActorReferenceChannel::HasDefault() { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingActorReferenceChannel", "HasDefault"); Params::UMovieSceneScriptingActorReferenceChannel_HasDefault_Params Parms{}; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneScriptingActorReferenceChannel.GetKeys // (Native, Public, BlueprintCallable, BlueprintPure, Const) // Parameters: // TArrayReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic) TArray UMovieSceneScriptingActorReferenceChannel::GetKeys() { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingActorReferenceChannel", "GetKeys"); Params::UMovieSceneScriptingActorReferenceChannel_GetKeys_Params Parms{}; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneScriptingActorReferenceChannel.GetDefault // (Final, Native, Public, BlueprintCallable, BlueprintPure, Const) // Parameters: // struct FMovieSceneObjectBindingID ReturnValue (Parm, OutParm, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) struct FMovieSceneObjectBindingID UMovieSceneScriptingActorReferenceChannel::GetDefault() { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingActorReferenceChannel", "GetDefault"); Params::UMovieSceneScriptingActorReferenceChannel_GetDefault_Params Parms{}; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneScriptingActorReferenceChannel.AddKey // (Final, Native, Public, HasDefaults, BlueprintCallable) // Parameters: // struct FFrameNumber InTime (ConstParm, Parm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // struct FMovieSceneObjectBindingID NewValue (Parm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // float SubFrame (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // enum class ESequenceTimeUnit TimeUnit (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // class UMovieSceneScriptingActorReferenceKey*ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) class UMovieSceneScriptingActorReferenceKey* UMovieSceneScriptingActorReferenceChannel::AddKey(const struct FFrameNumber& InTime, const struct FMovieSceneObjectBindingID& NewValue, float SubFrame, enum class ESequenceTimeUnit TimeUnit) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingActorReferenceChannel", "AddKey"); Params::UMovieSceneScriptingActorReferenceChannel_AddKey_Params Parms{}; Parms.InTime = InTime; Parms.NewValue = NewValue; Parms.SubFrame = SubFrame; Parms.TimeUnit = TimeUnit; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Class SequencerScripting.MovieSceneScriptingBoolKey // (None) class UClass* UMovieSceneScriptingBoolKey::StaticClass() { static class UClass* Clss = nullptr; if (!Clss) Clss = UObject::FindClassFast("MovieSceneScriptingBoolKey"); return Clss; } // MovieSceneScriptingBoolKey SequencerScripting.Default__MovieSceneScriptingBoolKey // (Public, ClassDefaultObject, ArchetypeObject) class UMovieSceneScriptingBoolKey* UMovieSceneScriptingBoolKey::GetDefaultObj() { static class UMovieSceneScriptingBoolKey* Default = nullptr; if (!Default) Default = static_cast(UMovieSceneScriptingBoolKey::StaticClass()->DefaultObject); return Default; } // Function SequencerScripting.MovieSceneScriptingBoolKey.SetValue // (Final, Native, Public, BlueprintCallable) // Parameters: // bool InNewValue (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) void UMovieSceneScriptingBoolKey::SetValue(bool InNewValue) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingBoolKey", "SetValue"); Params::UMovieSceneScriptingBoolKey_SetValue_Params Parms{}; Parms.InNewValue = InNewValue; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; } // Function SequencerScripting.MovieSceneScriptingBoolKey.SetTime // (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable) // Parameters: // struct FFrameNumber NewFrameNumber (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // float SubFrame (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // enum class ESequenceTimeUnit TimeUnit (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) void UMovieSceneScriptingBoolKey::SetTime(struct FFrameNumber& NewFrameNumber, float SubFrame, enum class ESequenceTimeUnit TimeUnit) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingBoolKey", "SetTime"); Params::UMovieSceneScriptingBoolKey_SetTime_Params Parms{}; Parms.NewFrameNumber = NewFrameNumber; Parms.SubFrame = SubFrame; Parms.TimeUnit = TimeUnit; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; } // Function SequencerScripting.MovieSceneScriptingBoolKey.GetValue // (Final, Native, Public, BlueprintCallable, BlueprintPure, Const) // Parameters: // bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) bool UMovieSceneScriptingBoolKey::GetValue() { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingBoolKey", "GetValue"); Params::UMovieSceneScriptingBoolKey_GetValue_Params Parms{}; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneScriptingBoolKey.GetTime // (Native, Public, BlueprintCallable, BlueprintPure, Const) // Parameters: // enum class ESequenceTimeUnit TimeUnit (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // struct FFrameTime ReturnValue (Parm, OutParm, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) struct FFrameTime UMovieSceneScriptingBoolKey::GetTime(enum class ESequenceTimeUnit TimeUnit) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingBoolKey", "GetTime"); Params::UMovieSceneScriptingBoolKey_GetTime_Params Parms{}; Parms.TimeUnit = TimeUnit; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Class SequencerScripting.MovieSceneScriptingBoolChannel // (None) class UClass* UMovieSceneScriptingBoolChannel::StaticClass() { static class UClass* Clss = nullptr; if (!Clss) Clss = UObject::FindClassFast("MovieSceneScriptingBoolChannel"); return Clss; } // MovieSceneScriptingBoolChannel SequencerScripting.Default__MovieSceneScriptingBoolChannel // (Public, ClassDefaultObject, ArchetypeObject) class UMovieSceneScriptingBoolChannel* UMovieSceneScriptingBoolChannel::GetDefaultObj() { static class UMovieSceneScriptingBoolChannel* Default = nullptr; if (!Default) Default = static_cast(UMovieSceneScriptingBoolChannel::StaticClass()->DefaultObject); return Default; } // Function SequencerScripting.MovieSceneScriptingBoolChannel.SetDefault // (Final, Native, Public, BlueprintCallable) // Parameters: // bool InDefaultValue (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) void UMovieSceneScriptingBoolChannel::SetDefault(bool InDefaultValue) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingBoolChannel", "SetDefault"); Params::UMovieSceneScriptingBoolChannel_SetDefault_Params Parms{}; Parms.InDefaultValue = InDefaultValue; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; } // Function SequencerScripting.MovieSceneScriptingBoolChannel.RemoveKey // (Native, Public, BlueprintCallable) // Parameters: // class UMovieSceneScriptingKey* Key (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) void UMovieSceneScriptingBoolChannel::RemoveKey(class UMovieSceneScriptingKey* Key) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingBoolChannel", "RemoveKey"); Params::UMovieSceneScriptingBoolChannel_RemoveKey_Params Parms{}; Parms.Key = Key; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; } // Function SequencerScripting.MovieSceneScriptingBoolChannel.RemoveDefault // (Final, Native, Public, BlueprintCallable) // Parameters: void UMovieSceneScriptingBoolChannel::RemoveDefault() { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingBoolChannel", "RemoveDefault"); auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, nullptr); Func->FunctionFlags = Flgs; } // Function SequencerScripting.MovieSceneScriptingBoolChannel.HasDefault // (Final, Native, Public, BlueprintCallable, BlueprintPure, Const) // Parameters: // bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) bool UMovieSceneScriptingBoolChannel::HasDefault() { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingBoolChannel", "HasDefault"); Params::UMovieSceneScriptingBoolChannel_HasDefault_Params Parms{}; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneScriptingBoolChannel.GetNumKeys // (Final, Native, Public, BlueprintCallable, BlueprintPure, Const) // Parameters: // int32 ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) int32 UMovieSceneScriptingBoolChannel::GetNumKeys() { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingBoolChannel", "GetNumKeys"); Params::UMovieSceneScriptingBoolChannel_GetNumKeys_Params Parms{}; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneScriptingBoolChannel.GetKeys // (Native, Public, BlueprintCallable, BlueprintPure, Const) // Parameters: // TArrayReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic) TArray UMovieSceneScriptingBoolChannel::GetKeys() { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingBoolChannel", "GetKeys"); Params::UMovieSceneScriptingBoolChannel_GetKeys_Params Parms{}; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneScriptingBoolChannel.GetDefault // (Final, Native, Public, BlueprintCallable, BlueprintPure, Const) // Parameters: // bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) bool UMovieSceneScriptingBoolChannel::GetDefault() { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingBoolChannel", "GetDefault"); Params::UMovieSceneScriptingBoolChannel_GetDefault_Params Parms{}; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneScriptingBoolChannel.EvaluateKeys // (Final, Native, Public, BlueprintCallable, BlueprintPure, Const) // Parameters: // struct FSequencerScriptingRange Range (Parm, NoDestructor, NativeAccessSpecifierPublic) // struct FFrameRate FrameRate (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // TArray ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic) TArray UMovieSceneScriptingBoolChannel::EvaluateKeys(const struct FSequencerScriptingRange& Range, const struct FFrameRate& FrameRate) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingBoolChannel", "EvaluateKeys"); Params::UMovieSceneScriptingBoolChannel_EvaluateKeys_Params Parms{}; Parms.Range = Range; Parms.FrameRate = FrameRate; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneScriptingBoolChannel.ComputeEffectiveRange // (Final, Native, Public, BlueprintCallable, BlueprintPure, Const) // Parameters: // struct FSequencerScriptingRange ReturnValue (Parm, OutParm, ReturnParm, NoDestructor, NativeAccessSpecifierPublic) struct FSequencerScriptingRange UMovieSceneScriptingBoolChannel::ComputeEffectiveRange() { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingBoolChannel", "ComputeEffectiveRange"); Params::UMovieSceneScriptingBoolChannel_ComputeEffectiveRange_Params Parms{}; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneScriptingBoolChannel.AddKey // (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable) // Parameters: // struct FFrameNumber InTime (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // bool NewValue (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // float SubFrame (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // enum class ESequenceTimeUnit TimeUnit (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // class UMovieSceneScriptingBoolKey* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) class UMovieSceneScriptingBoolKey* UMovieSceneScriptingBoolChannel::AddKey(struct FFrameNumber& InTime, bool NewValue, float SubFrame, enum class ESequenceTimeUnit TimeUnit) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingBoolChannel", "AddKey"); Params::UMovieSceneScriptingBoolChannel_AddKey_Params Parms{}; Parms.InTime = InTime; Parms.NewValue = NewValue; Parms.SubFrame = SubFrame; Parms.TimeUnit = TimeUnit; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Class SequencerScripting.MovieSceneScriptingByteKey // (None) class UClass* UMovieSceneScriptingByteKey::StaticClass() { static class UClass* Clss = nullptr; if (!Clss) Clss = UObject::FindClassFast("MovieSceneScriptingByteKey"); return Clss; } // MovieSceneScriptingByteKey SequencerScripting.Default__MovieSceneScriptingByteKey // (Public, ClassDefaultObject, ArchetypeObject) class UMovieSceneScriptingByteKey* UMovieSceneScriptingByteKey::GetDefaultObj() { static class UMovieSceneScriptingByteKey* Default = nullptr; if (!Default) Default = static_cast(UMovieSceneScriptingByteKey::StaticClass()->DefaultObject); return Default; } // Function SequencerScripting.MovieSceneScriptingByteKey.SetValue // (Final, Native, Public, BlueprintCallable) // Parameters: // uint8 InNewValue (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) void UMovieSceneScriptingByteKey::SetValue(uint8 InNewValue) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingByteKey", "SetValue"); Params::UMovieSceneScriptingByteKey_SetValue_Params Parms{}; Parms.InNewValue = InNewValue; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; } // Function SequencerScripting.MovieSceneScriptingByteKey.SetTime // (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable) // Parameters: // struct FFrameNumber NewFrameNumber (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // float SubFrame (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // enum class ESequenceTimeUnit TimeUnit (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) void UMovieSceneScriptingByteKey::SetTime(struct FFrameNumber& NewFrameNumber, float SubFrame, enum class ESequenceTimeUnit TimeUnit) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingByteKey", "SetTime"); Params::UMovieSceneScriptingByteKey_SetTime_Params Parms{}; Parms.NewFrameNumber = NewFrameNumber; Parms.SubFrame = SubFrame; Parms.TimeUnit = TimeUnit; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; } // Function SequencerScripting.MovieSceneScriptingByteKey.GetValue // (Final, Native, Public, BlueprintCallable, BlueprintPure, Const) // Parameters: // uint8 ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) uint8 UMovieSceneScriptingByteKey::GetValue() { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingByteKey", "GetValue"); Params::UMovieSceneScriptingByteKey_GetValue_Params Parms{}; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneScriptingByteKey.GetTime // (Native, Public, BlueprintCallable, BlueprintPure, Const) // Parameters: // enum class ESequenceTimeUnit TimeUnit (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // struct FFrameTime ReturnValue (Parm, OutParm, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) struct FFrameTime UMovieSceneScriptingByteKey::GetTime(enum class ESequenceTimeUnit TimeUnit) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingByteKey", "GetTime"); Params::UMovieSceneScriptingByteKey_GetTime_Params Parms{}; Parms.TimeUnit = TimeUnit; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Class SequencerScripting.MovieSceneScriptingByteChannel // (None) class UClass* UMovieSceneScriptingByteChannel::StaticClass() { static class UClass* Clss = nullptr; if (!Clss) Clss = UObject::FindClassFast("MovieSceneScriptingByteChannel"); return Clss; } // MovieSceneScriptingByteChannel SequencerScripting.Default__MovieSceneScriptingByteChannel // (Public, ClassDefaultObject, ArchetypeObject) class UMovieSceneScriptingByteChannel* UMovieSceneScriptingByteChannel::GetDefaultObj() { static class UMovieSceneScriptingByteChannel* Default = nullptr; if (!Default) Default = static_cast(UMovieSceneScriptingByteChannel::StaticClass()->DefaultObject); return Default; } // Function SequencerScripting.MovieSceneScriptingByteChannel.SetDefault // (Final, Native, Public, BlueprintCallable) // Parameters: // uint8 InDefaultValue (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) void UMovieSceneScriptingByteChannel::SetDefault(uint8 InDefaultValue) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingByteChannel", "SetDefault"); Params::UMovieSceneScriptingByteChannel_SetDefault_Params Parms{}; Parms.InDefaultValue = InDefaultValue; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; } // Function SequencerScripting.MovieSceneScriptingByteChannel.RemoveKey // (Native, Public, BlueprintCallable) // Parameters: // class UMovieSceneScriptingKey* Key (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) void UMovieSceneScriptingByteChannel::RemoveKey(class UMovieSceneScriptingKey* Key) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingByteChannel", "RemoveKey"); Params::UMovieSceneScriptingByteChannel_RemoveKey_Params Parms{}; Parms.Key = Key; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; } // Function SequencerScripting.MovieSceneScriptingByteChannel.RemoveDefault // (Final, Native, Public, BlueprintCallable) // Parameters: void UMovieSceneScriptingByteChannel::RemoveDefault() { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingByteChannel", "RemoveDefault"); auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, nullptr); Func->FunctionFlags = Flgs; } // Function SequencerScripting.MovieSceneScriptingByteChannel.HasDefault // (Final, Native, Public, BlueprintCallable, BlueprintPure, Const) // Parameters: // bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) bool UMovieSceneScriptingByteChannel::HasDefault() { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingByteChannel", "HasDefault"); Params::UMovieSceneScriptingByteChannel_HasDefault_Params Parms{}; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneScriptingByteChannel.GetKeys // (Native, Public, BlueprintCallable, BlueprintPure, Const) // Parameters: // TArrayReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic) TArray UMovieSceneScriptingByteChannel::GetKeys() { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingByteChannel", "GetKeys"); Params::UMovieSceneScriptingByteChannel_GetKeys_Params Parms{}; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneScriptingByteChannel.GetDefault // (Final, Native, Public, BlueprintCallable, BlueprintPure, Const) // Parameters: // uint8 ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) uint8 UMovieSceneScriptingByteChannel::GetDefault() { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingByteChannel", "GetDefault"); Params::UMovieSceneScriptingByteChannel_GetDefault_Params Parms{}; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneScriptingByteChannel.AddKey // (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable) // Parameters: // struct FFrameNumber InTime (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // uint8 NewValue (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // float SubFrame (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // enum class ESequenceTimeUnit TimeUnit (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // enum class EMovieSceneKeyInterpolationInInterpolation (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // class UMovieSceneScriptingByteKey* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) class UMovieSceneScriptingByteKey* UMovieSceneScriptingByteChannel::AddKey(struct FFrameNumber& InTime, uint8 NewValue, float SubFrame, enum class ESequenceTimeUnit TimeUnit, enum class EMovieSceneKeyInterpolation InInterpolation) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingByteChannel", "AddKey"); Params::UMovieSceneScriptingByteChannel_AddKey_Params Parms{}; Parms.InTime = InTime; Parms.NewValue = NewValue; Parms.SubFrame = SubFrame; Parms.TimeUnit = TimeUnit; Parms.InInterpolation = InInterpolation; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Class SequencerScripting.MovieSceneScriptingDoubleKey // (None) class UClass* UMovieSceneScriptingDoubleKey::StaticClass() { static class UClass* Clss = nullptr; if (!Clss) Clss = UObject::FindClassFast("MovieSceneScriptingDoubleKey"); return Clss; } // MovieSceneScriptingDoubleKey SequencerScripting.Default__MovieSceneScriptingDoubleKey // (Public, ClassDefaultObject, ArchetypeObject) class UMovieSceneScriptingDoubleKey* UMovieSceneScriptingDoubleKey::GetDefaultObj() { static class UMovieSceneScriptingDoubleKey* Default = nullptr; if (!Default) Default = static_cast(UMovieSceneScriptingDoubleKey::StaticClass()->DefaultObject); return Default; } // Function SequencerScripting.MovieSceneScriptingDoubleKey.SetValue // (Final, Native, Public, BlueprintCallable) // Parameters: // double InNewValue (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) void UMovieSceneScriptingDoubleKey::SetValue(double InNewValue) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingDoubleKey", "SetValue"); Params::UMovieSceneScriptingDoubleKey_SetValue_Params Parms{}; Parms.InNewValue = InNewValue; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; } // Function SequencerScripting.MovieSceneScriptingDoubleKey.SetTime // (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable) // Parameters: // struct FFrameNumber NewFrameNumber (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // float SubFrame (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // enum class ESequenceTimeUnit TimeUnit (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) void UMovieSceneScriptingDoubleKey::SetTime(struct FFrameNumber& NewFrameNumber, float SubFrame, enum class ESequenceTimeUnit TimeUnit) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingDoubleKey", "SetTime"); Params::UMovieSceneScriptingDoubleKey_SetTime_Params Parms{}; Parms.NewFrameNumber = NewFrameNumber; Parms.SubFrame = SubFrame; Parms.TimeUnit = TimeUnit; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; } // Function SequencerScripting.MovieSceneScriptingDoubleKey.SetTangentWeightMode // (Final, Native, Public, BlueprintCallable) // Parameters: // enum class ERichCurveTangentWeightModeInNewValue (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) void UMovieSceneScriptingDoubleKey::SetTangentWeightMode(enum class ERichCurveTangentWeightMode InNewValue) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingDoubleKey", "SetTangentWeightMode"); Params::UMovieSceneScriptingDoubleKey_SetTangentWeightMode_Params Parms{}; Parms.InNewValue = InNewValue; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; } // Function SequencerScripting.MovieSceneScriptingDoubleKey.SetTangentMode // (Final, Native, Public, BlueprintCallable) // Parameters: // enum class ERichCurveTangentMode InNewValue (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) void UMovieSceneScriptingDoubleKey::SetTangentMode(enum class ERichCurveTangentMode InNewValue) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingDoubleKey", "SetTangentMode"); Params::UMovieSceneScriptingDoubleKey_SetTangentMode_Params Parms{}; Parms.InNewValue = InNewValue; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; } // Function SequencerScripting.MovieSceneScriptingDoubleKey.SetLeaveTangentWeight // (Final, Native, Public, BlueprintCallable) // Parameters: // float InNewValue (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) void UMovieSceneScriptingDoubleKey::SetLeaveTangentWeight(float InNewValue) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingDoubleKey", "SetLeaveTangentWeight"); Params::UMovieSceneScriptingDoubleKey_SetLeaveTangentWeight_Params Parms{}; Parms.InNewValue = InNewValue; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; } // Function SequencerScripting.MovieSceneScriptingDoubleKey.SetLeaveTangent // (Final, Native, Public, BlueprintCallable) // Parameters: // float InNewValue (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) void UMovieSceneScriptingDoubleKey::SetLeaveTangent(float InNewValue) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingDoubleKey", "SetLeaveTangent"); Params::UMovieSceneScriptingDoubleKey_SetLeaveTangent_Params Parms{}; Parms.InNewValue = InNewValue; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; } // Function SequencerScripting.MovieSceneScriptingDoubleKey.SetInterpolationMode // (Final, Native, Public, BlueprintCallable) // Parameters: // enum class ERichCurveInterpMode InNewValue (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) void UMovieSceneScriptingDoubleKey::SetInterpolationMode(enum class ERichCurveInterpMode InNewValue) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingDoubleKey", "SetInterpolationMode"); Params::UMovieSceneScriptingDoubleKey_SetInterpolationMode_Params Parms{}; Parms.InNewValue = InNewValue; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; } // Function SequencerScripting.MovieSceneScriptingDoubleKey.SetArriveTangentWeight // (Final, Native, Public, BlueprintCallable) // Parameters: // float InNewValue (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) void UMovieSceneScriptingDoubleKey::SetArriveTangentWeight(float InNewValue) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingDoubleKey", "SetArriveTangentWeight"); Params::UMovieSceneScriptingDoubleKey_SetArriveTangentWeight_Params Parms{}; Parms.InNewValue = InNewValue; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; } // Function SequencerScripting.MovieSceneScriptingDoubleKey.SetArriveTangent // (Final, Native, Public, BlueprintCallable) // Parameters: // float InNewValue (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) void UMovieSceneScriptingDoubleKey::SetArriveTangent(float InNewValue) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingDoubleKey", "SetArriveTangent"); Params::UMovieSceneScriptingDoubleKey_SetArriveTangent_Params Parms{}; Parms.InNewValue = InNewValue; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; } // Function SequencerScripting.MovieSceneScriptingDoubleKey.GetValue // (Final, Native, Public, BlueprintCallable, BlueprintPure, Const) // Parameters: // double ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) double UMovieSceneScriptingDoubleKey::GetValue() { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingDoubleKey", "GetValue"); Params::UMovieSceneScriptingDoubleKey_GetValue_Params Parms{}; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneScriptingDoubleKey.GetTime // (Native, Public, BlueprintCallable, BlueprintPure, Const) // Parameters: // enum class ESequenceTimeUnit TimeUnit (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // struct FFrameTime ReturnValue (Parm, OutParm, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) struct FFrameTime UMovieSceneScriptingDoubleKey::GetTime(enum class ESequenceTimeUnit TimeUnit) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingDoubleKey", "GetTime"); Params::UMovieSceneScriptingDoubleKey_GetTime_Params Parms{}; Parms.TimeUnit = TimeUnit; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneScriptingDoubleKey.GetTangentWeightMode // (Final, Native, Public, BlueprintCallable, BlueprintPure, Const) // Parameters: // enum class ERichCurveTangentWeightModeReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) enum class ERichCurveTangentWeightMode UMovieSceneScriptingDoubleKey::GetTangentWeightMode() { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingDoubleKey", "GetTangentWeightMode"); Params::UMovieSceneScriptingDoubleKey_GetTangentWeightMode_Params Parms{}; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneScriptingDoubleKey.GetTangentMode // (Final, Native, Public, BlueprintCallable, BlueprintPure, Const) // Parameters: // enum class ERichCurveTangentMode ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) enum class ERichCurveTangentMode UMovieSceneScriptingDoubleKey::GetTangentMode() { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingDoubleKey", "GetTangentMode"); Params::UMovieSceneScriptingDoubleKey_GetTangentMode_Params Parms{}; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneScriptingDoubleKey.GetLeaveTangentWeight // (Final, Native, Public, BlueprintCallable, BlueprintPure, Const) // Parameters: // float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) float UMovieSceneScriptingDoubleKey::GetLeaveTangentWeight() { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingDoubleKey", "GetLeaveTangentWeight"); Params::UMovieSceneScriptingDoubleKey_GetLeaveTangentWeight_Params Parms{}; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneScriptingDoubleKey.GetLeaveTangent // (Final, Native, Public, BlueprintCallable, BlueprintPure, Const) // Parameters: // float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) float UMovieSceneScriptingDoubleKey::GetLeaveTangent() { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingDoubleKey", "GetLeaveTangent"); Params::UMovieSceneScriptingDoubleKey_GetLeaveTangent_Params Parms{}; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneScriptingDoubleKey.GetInterpolationMode // (Final, Native, Public, BlueprintCallable, BlueprintPure, Const) // Parameters: // enum class ERichCurveInterpMode ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) enum class ERichCurveInterpMode UMovieSceneScriptingDoubleKey::GetInterpolationMode() { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingDoubleKey", "GetInterpolationMode"); Params::UMovieSceneScriptingDoubleKey_GetInterpolationMode_Params Parms{}; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneScriptingDoubleKey.GetArriveTangentWeight // (Final, Native, Public, BlueprintCallable, BlueprintPure, Const) // Parameters: // float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) float UMovieSceneScriptingDoubleKey::GetArriveTangentWeight() { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingDoubleKey", "GetArriveTangentWeight"); Params::UMovieSceneScriptingDoubleKey_GetArriveTangentWeight_Params Parms{}; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneScriptingDoubleKey.GetArriveTangent // (Final, Native, Public, BlueprintCallable, BlueprintPure, Const) // Parameters: // float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) float UMovieSceneScriptingDoubleKey::GetArriveTangent() { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingDoubleKey", "GetArriveTangent"); Params::UMovieSceneScriptingDoubleKey_GetArriveTangent_Params Parms{}; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Class SequencerScripting.MovieSceneScriptingDoubleChannel // (None) class UClass* UMovieSceneScriptingDoubleChannel::StaticClass() { static class UClass* Clss = nullptr; if (!Clss) Clss = UObject::FindClassFast("MovieSceneScriptingDoubleChannel"); return Clss; } // MovieSceneScriptingDoubleChannel SequencerScripting.Default__MovieSceneScriptingDoubleChannel // (Public, ClassDefaultObject, ArchetypeObject) class UMovieSceneScriptingDoubleChannel* UMovieSceneScriptingDoubleChannel::GetDefaultObj() { static class UMovieSceneScriptingDoubleChannel* Default = nullptr; if (!Default) Default = static_cast(UMovieSceneScriptingDoubleChannel::StaticClass()->DefaultObject); return Default; } // Function SequencerScripting.MovieSceneScriptingDoubleChannel.SetPreInfinityExtrapolation // (Final, Native, Public, BlueprintCallable) // Parameters: // enum class ERichCurveExtrapolation InExtrapolation (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) void UMovieSceneScriptingDoubleChannel::SetPreInfinityExtrapolation(enum class ERichCurveExtrapolation InExtrapolation) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingDoubleChannel", "SetPreInfinityExtrapolation"); Params::UMovieSceneScriptingDoubleChannel_SetPreInfinityExtrapolation_Params Parms{}; Parms.InExtrapolation = InExtrapolation; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; } // Function SequencerScripting.MovieSceneScriptingDoubleChannel.SetPostInfinityExtrapolation // (Final, Native, Public, BlueprintCallable) // Parameters: // enum class ERichCurveExtrapolation InExtrapolation (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) void UMovieSceneScriptingDoubleChannel::SetPostInfinityExtrapolation(enum class ERichCurveExtrapolation InExtrapolation) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingDoubleChannel", "SetPostInfinityExtrapolation"); Params::UMovieSceneScriptingDoubleChannel_SetPostInfinityExtrapolation_Params Parms{}; Parms.InExtrapolation = InExtrapolation; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; } // Function SequencerScripting.MovieSceneScriptingDoubleChannel.SetDefault // (Final, Native, Public, BlueprintCallable) // Parameters: // double InDefaultValue (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) void UMovieSceneScriptingDoubleChannel::SetDefault(double InDefaultValue) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingDoubleChannel", "SetDefault"); Params::UMovieSceneScriptingDoubleChannel_SetDefault_Params Parms{}; Parms.InDefaultValue = InDefaultValue; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; } // Function SequencerScripting.MovieSceneScriptingDoubleChannel.RemoveKey // (Native, Public, BlueprintCallable) // Parameters: // class UMovieSceneScriptingKey* Key (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) void UMovieSceneScriptingDoubleChannel::RemoveKey(class UMovieSceneScriptingKey* Key) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingDoubleChannel", "RemoveKey"); Params::UMovieSceneScriptingDoubleChannel_RemoveKey_Params Parms{}; Parms.Key = Key; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; } // Function SequencerScripting.MovieSceneScriptingDoubleChannel.RemoveDefault // (Final, Native, Public, BlueprintCallable) // Parameters: void UMovieSceneScriptingDoubleChannel::RemoveDefault() { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingDoubleChannel", "RemoveDefault"); auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, nullptr); Func->FunctionFlags = Flgs; } // Function SequencerScripting.MovieSceneScriptingDoubleChannel.HasDefault // (Final, Native, Public, BlueprintCallable, BlueprintPure, Const) // Parameters: // bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) bool UMovieSceneScriptingDoubleChannel::HasDefault() { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingDoubleChannel", "HasDefault"); Params::UMovieSceneScriptingDoubleChannel_HasDefault_Params Parms{}; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneScriptingDoubleChannel.GetPreInfinityExtrapolation // (Final, Native, Public, BlueprintCallable, BlueprintPure, Const) // Parameters: // enum class ERichCurveExtrapolation ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) enum class ERichCurveExtrapolation UMovieSceneScriptingDoubleChannel::GetPreInfinityExtrapolation() { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingDoubleChannel", "GetPreInfinityExtrapolation"); Params::UMovieSceneScriptingDoubleChannel_GetPreInfinityExtrapolation_Params Parms{}; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneScriptingDoubleChannel.GetPostInfinityExtrapolation // (Final, Native, Public, BlueprintCallable, BlueprintPure, Const) // Parameters: // enum class ERichCurveExtrapolation ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) enum class ERichCurveExtrapolation UMovieSceneScriptingDoubleChannel::GetPostInfinityExtrapolation() { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingDoubleChannel", "GetPostInfinityExtrapolation"); Params::UMovieSceneScriptingDoubleChannel_GetPostInfinityExtrapolation_Params Parms{}; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneScriptingDoubleChannel.GetNumKeys // (Final, Native, Public, BlueprintCallable, BlueprintPure, Const) // Parameters: // int32 ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) int32 UMovieSceneScriptingDoubleChannel::GetNumKeys() { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingDoubleChannel", "GetNumKeys"); Params::UMovieSceneScriptingDoubleChannel_GetNumKeys_Params Parms{}; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneScriptingDoubleChannel.GetKeys // (Native, Public, BlueprintCallable, BlueprintPure, Const) // Parameters: // TArrayReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic) TArray UMovieSceneScriptingDoubleChannel::GetKeys() { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingDoubleChannel", "GetKeys"); Params::UMovieSceneScriptingDoubleChannel_GetKeys_Params Parms{}; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneScriptingDoubleChannel.GetDefault // (Final, Native, Public, BlueprintCallable, BlueprintPure, Const) // Parameters: // double ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) double UMovieSceneScriptingDoubleChannel::GetDefault() { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingDoubleChannel", "GetDefault"); Params::UMovieSceneScriptingDoubleChannel_GetDefault_Params Parms{}; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneScriptingDoubleChannel.EvaluateKeys // (Final, Native, Public, BlueprintCallable, BlueprintPure, Const) // Parameters: // struct FSequencerScriptingRange Range (Parm, NoDestructor, NativeAccessSpecifierPublic) // struct FFrameRate FrameRate (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // TArray ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic) TArray UMovieSceneScriptingDoubleChannel::EvaluateKeys(const struct FSequencerScriptingRange& Range, const struct FFrameRate& FrameRate) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingDoubleChannel", "EvaluateKeys"); Params::UMovieSceneScriptingDoubleChannel_EvaluateKeys_Params Parms{}; Parms.Range = Range; Parms.FrameRate = FrameRate; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneScriptingDoubleChannel.ComputeEffectiveRange // (Final, Native, Public, BlueprintCallable, BlueprintPure, Const) // Parameters: // struct FSequencerScriptingRange ReturnValue (Parm, OutParm, ReturnParm, NoDestructor, NativeAccessSpecifierPublic) struct FSequencerScriptingRange UMovieSceneScriptingDoubleChannel::ComputeEffectiveRange() { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingDoubleChannel", "ComputeEffectiveRange"); Params::UMovieSceneScriptingDoubleChannel_ComputeEffectiveRange_Params Parms{}; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneScriptingDoubleChannel.AddKey // (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable) // Parameters: // struct FFrameNumber InTime (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // double NewValue (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // float SubFrame (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // enum class ESequenceTimeUnit TimeUnit (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // enum class EMovieSceneKeyInterpolationInInterpolation (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // class UMovieSceneScriptingDoubleKey*ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) class UMovieSceneScriptingDoubleKey* UMovieSceneScriptingDoubleChannel::AddKey(struct FFrameNumber& InTime, double NewValue, float SubFrame, enum class ESequenceTimeUnit TimeUnit, enum class EMovieSceneKeyInterpolation InInterpolation) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingDoubleChannel", "AddKey"); Params::UMovieSceneScriptingDoubleChannel_AddKey_Params Parms{}; Parms.InTime = InTime; Parms.NewValue = NewValue; Parms.SubFrame = SubFrame; Parms.TimeUnit = TimeUnit; Parms.InInterpolation = InInterpolation; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Class SequencerScripting.MovieSceneScriptingEventKey // (None) class UClass* UMovieSceneScriptingEventKey::StaticClass() { static class UClass* Clss = nullptr; if (!Clss) Clss = UObject::FindClassFast("MovieSceneScriptingEventKey"); return Clss; } // MovieSceneScriptingEventKey SequencerScripting.Default__MovieSceneScriptingEventKey // (Public, ClassDefaultObject, ArchetypeObject) class UMovieSceneScriptingEventKey* UMovieSceneScriptingEventKey::GetDefaultObj() { static class UMovieSceneScriptingEventKey* Default = nullptr; if (!Default) Default = static_cast(UMovieSceneScriptingEventKey::StaticClass()->DefaultObject); return Default; } // Function SequencerScripting.MovieSceneScriptingEventKey.SetValue // (Final, Native, Public, HasOutParams, BlueprintCallable) // Parameters: // struct FMovieSceneEvent InNewValue (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic) void UMovieSceneScriptingEventKey::SetValue(struct FMovieSceneEvent& InNewValue) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingEventKey", "SetValue"); Params::UMovieSceneScriptingEventKey_SetValue_Params Parms{}; Parms.InNewValue = InNewValue; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; } // Function SequencerScripting.MovieSceneScriptingEventKey.SetTime // (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable) // Parameters: // struct FFrameNumber NewFrameNumber (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // float SubFrame (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // enum class ESequenceTimeUnit TimeUnit (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) void UMovieSceneScriptingEventKey::SetTime(struct FFrameNumber& NewFrameNumber, float SubFrame, enum class ESequenceTimeUnit TimeUnit) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingEventKey", "SetTime"); Params::UMovieSceneScriptingEventKey_SetTime_Params Parms{}; Parms.NewFrameNumber = NewFrameNumber; Parms.SubFrame = SubFrame; Parms.TimeUnit = TimeUnit; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; } // Function SequencerScripting.MovieSceneScriptingEventKey.GetValue // (Final, Native, Public, BlueprintCallable, BlueprintPure, Const) // Parameters: // struct FMovieSceneEvent ReturnValue (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic) struct FMovieSceneEvent UMovieSceneScriptingEventKey::GetValue() { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingEventKey", "GetValue"); Params::UMovieSceneScriptingEventKey_GetValue_Params Parms{}; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneScriptingEventKey.GetTime // (Native, Public, BlueprintCallable, BlueprintPure, Const) // Parameters: // enum class ESequenceTimeUnit TimeUnit (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // struct FFrameTime ReturnValue (Parm, OutParm, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) struct FFrameTime UMovieSceneScriptingEventKey::GetTime(enum class ESequenceTimeUnit TimeUnit) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingEventKey", "GetTime"); Params::UMovieSceneScriptingEventKey_GetTime_Params Parms{}; Parms.TimeUnit = TimeUnit; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Class SequencerScripting.MovieSceneScriptingEventChannel // (None) class UClass* UMovieSceneScriptingEventChannel::StaticClass() { static class UClass* Clss = nullptr; if (!Clss) Clss = UObject::FindClassFast("MovieSceneScriptingEventChannel"); return Clss; } // MovieSceneScriptingEventChannel SequencerScripting.Default__MovieSceneScriptingEventChannel // (Public, ClassDefaultObject, ArchetypeObject) class UMovieSceneScriptingEventChannel* UMovieSceneScriptingEventChannel::GetDefaultObj() { static class UMovieSceneScriptingEventChannel* Default = nullptr; if (!Default) Default = static_cast(UMovieSceneScriptingEventChannel::StaticClass()->DefaultObject); return Default; } // Function SequencerScripting.MovieSceneScriptingEventChannel.RemoveKey // (Native, Public, BlueprintCallable) // Parameters: // class UMovieSceneScriptingKey* Key (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) void UMovieSceneScriptingEventChannel::RemoveKey(class UMovieSceneScriptingKey* Key) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingEventChannel", "RemoveKey"); Params::UMovieSceneScriptingEventChannel_RemoveKey_Params Parms{}; Parms.Key = Key; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; } // Function SequencerScripting.MovieSceneScriptingEventChannel.GetKeys // (Native, Public, BlueprintCallable, BlueprintPure, Const) // Parameters: // TArrayReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic) TArray UMovieSceneScriptingEventChannel::GetKeys() { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingEventChannel", "GetKeys"); Params::UMovieSceneScriptingEventChannel_GetKeys_Params Parms{}; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneScriptingEventChannel.AddKey // (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable) // Parameters: // struct FFrameNumber InTime (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // struct FMovieSceneEvent NewValue (Parm, NativeAccessSpecifierPublic) // float SubFrame (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // enum class ESequenceTimeUnit TimeUnit (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // class UMovieSceneScriptingEventKey*ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) class UMovieSceneScriptingEventKey* UMovieSceneScriptingEventChannel::AddKey(struct FFrameNumber& InTime, const struct FMovieSceneEvent& NewValue, float SubFrame, enum class ESequenceTimeUnit TimeUnit) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingEventChannel", "AddKey"); Params::UMovieSceneScriptingEventChannel_AddKey_Params Parms{}; Parms.InTime = InTime; Parms.NewValue = NewValue; Parms.SubFrame = SubFrame; Parms.TimeUnit = TimeUnit; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Class SequencerScripting.MovieSceneScriptingFloatKey // (None) class UClass* UMovieSceneScriptingFloatKey::StaticClass() { static class UClass* Clss = nullptr; if (!Clss) Clss = UObject::FindClassFast("MovieSceneScriptingFloatKey"); return Clss; } // MovieSceneScriptingFloatKey SequencerScripting.Default__MovieSceneScriptingFloatKey // (Public, ClassDefaultObject, ArchetypeObject) class UMovieSceneScriptingFloatKey* UMovieSceneScriptingFloatKey::GetDefaultObj() { static class UMovieSceneScriptingFloatKey* Default = nullptr; if (!Default) Default = static_cast(UMovieSceneScriptingFloatKey::StaticClass()->DefaultObject); return Default; } // Function SequencerScripting.MovieSceneScriptingFloatKey.SetValue // (Native, Public, BlueprintCallable) // Parameters: // float InNewValue (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) void UMovieSceneScriptingFloatKey::SetValue(float InNewValue) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingFloatKey", "SetValue"); Params::UMovieSceneScriptingFloatKey_SetValue_Params Parms{}; Parms.InNewValue = InNewValue; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; } // Function SequencerScripting.MovieSceneScriptingFloatKey.SetTime // (Native, Public, HasOutParams, HasDefaults, BlueprintCallable) // Parameters: // struct FFrameNumber NewFrameNumber (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // float SubFrame (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // enum class ESequenceTimeUnit TimeUnit (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) void UMovieSceneScriptingFloatKey::SetTime(struct FFrameNumber& NewFrameNumber, float SubFrame, enum class ESequenceTimeUnit TimeUnit) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingFloatKey", "SetTime"); Params::UMovieSceneScriptingFloatKey_SetTime_Params Parms{}; Parms.NewFrameNumber = NewFrameNumber; Parms.SubFrame = SubFrame; Parms.TimeUnit = TimeUnit; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; } // Function SequencerScripting.MovieSceneScriptingFloatKey.SetTangentWeightMode // (Native, Public, BlueprintCallable) // Parameters: // enum class ERichCurveTangentWeightModeInNewValue (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) void UMovieSceneScriptingFloatKey::SetTangentWeightMode(enum class ERichCurveTangentWeightMode InNewValue) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingFloatKey", "SetTangentWeightMode"); Params::UMovieSceneScriptingFloatKey_SetTangentWeightMode_Params Parms{}; Parms.InNewValue = InNewValue; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; } // Function SequencerScripting.MovieSceneScriptingFloatKey.SetTangentMode // (Native, Public, BlueprintCallable) // Parameters: // enum class ERichCurveTangentMode InNewValue (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) void UMovieSceneScriptingFloatKey::SetTangentMode(enum class ERichCurveTangentMode InNewValue) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingFloatKey", "SetTangentMode"); Params::UMovieSceneScriptingFloatKey_SetTangentMode_Params Parms{}; Parms.InNewValue = InNewValue; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; } // Function SequencerScripting.MovieSceneScriptingFloatKey.SetLeaveTangentWeight // (Native, Public, BlueprintCallable) // Parameters: // float InNewValue (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) void UMovieSceneScriptingFloatKey::SetLeaveTangentWeight(float InNewValue) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingFloatKey", "SetLeaveTangentWeight"); Params::UMovieSceneScriptingFloatKey_SetLeaveTangentWeight_Params Parms{}; Parms.InNewValue = InNewValue; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; } // Function SequencerScripting.MovieSceneScriptingFloatKey.SetLeaveTangent // (Native, Public, BlueprintCallable) // Parameters: // float InNewValue (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) void UMovieSceneScriptingFloatKey::SetLeaveTangent(float InNewValue) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingFloatKey", "SetLeaveTangent"); Params::UMovieSceneScriptingFloatKey_SetLeaveTangent_Params Parms{}; Parms.InNewValue = InNewValue; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; } // Function SequencerScripting.MovieSceneScriptingFloatKey.SetInterpolationMode // (Native, Public, BlueprintCallable) // Parameters: // enum class ERichCurveInterpMode InNewValue (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) void UMovieSceneScriptingFloatKey::SetInterpolationMode(enum class ERichCurveInterpMode InNewValue) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingFloatKey", "SetInterpolationMode"); Params::UMovieSceneScriptingFloatKey_SetInterpolationMode_Params Parms{}; Parms.InNewValue = InNewValue; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; } // Function SequencerScripting.MovieSceneScriptingFloatKey.SetArriveTangentWeight // (Native, Public, BlueprintCallable) // Parameters: // float InNewValue (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) void UMovieSceneScriptingFloatKey::SetArriveTangentWeight(float InNewValue) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingFloatKey", "SetArriveTangentWeight"); Params::UMovieSceneScriptingFloatKey_SetArriveTangentWeight_Params Parms{}; Parms.InNewValue = InNewValue; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; } // Function SequencerScripting.MovieSceneScriptingFloatKey.SetArriveTangent // (Native, Public, BlueprintCallable) // Parameters: // float InNewValue (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) void UMovieSceneScriptingFloatKey::SetArriveTangent(float InNewValue) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingFloatKey", "SetArriveTangent"); Params::UMovieSceneScriptingFloatKey_SetArriveTangent_Params Parms{}; Parms.InNewValue = InNewValue; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; } // Function SequencerScripting.MovieSceneScriptingFloatKey.GetValue // (Native, Public, BlueprintCallable, BlueprintPure, Const) // Parameters: // float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) float UMovieSceneScriptingFloatKey::GetValue() { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingFloatKey", "GetValue"); Params::UMovieSceneScriptingFloatKey_GetValue_Params Parms{}; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneScriptingFloatKey.GetTime // (Native, Public, BlueprintCallable, BlueprintPure, Const) // Parameters: // enum class ESequenceTimeUnit TimeUnit (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // struct FFrameTime ReturnValue (Parm, OutParm, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) struct FFrameTime UMovieSceneScriptingFloatKey::GetTime(enum class ESequenceTimeUnit TimeUnit) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingFloatKey", "GetTime"); Params::UMovieSceneScriptingFloatKey_GetTime_Params Parms{}; Parms.TimeUnit = TimeUnit; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneScriptingFloatKey.GetTangentWeightMode // (Native, Public, BlueprintCallable, BlueprintPure, Const) // Parameters: // enum class ERichCurveTangentWeightModeReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) enum class ERichCurveTangentWeightMode UMovieSceneScriptingFloatKey::GetTangentWeightMode() { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingFloatKey", "GetTangentWeightMode"); Params::UMovieSceneScriptingFloatKey_GetTangentWeightMode_Params Parms{}; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneScriptingFloatKey.GetTangentMode // (Native, Public, BlueprintCallable, BlueprintPure, Const) // Parameters: // enum class ERichCurveTangentMode ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) enum class ERichCurveTangentMode UMovieSceneScriptingFloatKey::GetTangentMode() { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingFloatKey", "GetTangentMode"); Params::UMovieSceneScriptingFloatKey_GetTangentMode_Params Parms{}; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneScriptingFloatKey.GetLeaveTangentWeight // (Native, Public, BlueprintCallable, BlueprintPure, Const) // Parameters: // float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) float UMovieSceneScriptingFloatKey::GetLeaveTangentWeight() { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingFloatKey", "GetLeaveTangentWeight"); Params::UMovieSceneScriptingFloatKey_GetLeaveTangentWeight_Params Parms{}; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneScriptingFloatKey.GetLeaveTangent // (Native, Public, BlueprintCallable, BlueprintPure, Const) // Parameters: // float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) float UMovieSceneScriptingFloatKey::GetLeaveTangent() { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingFloatKey", "GetLeaveTangent"); Params::UMovieSceneScriptingFloatKey_GetLeaveTangent_Params Parms{}; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneScriptingFloatKey.GetInterpolationMode // (Native, Public, BlueprintCallable, BlueprintPure, Const) // Parameters: // enum class ERichCurveInterpMode ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) enum class ERichCurveInterpMode UMovieSceneScriptingFloatKey::GetInterpolationMode() { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingFloatKey", "GetInterpolationMode"); Params::UMovieSceneScriptingFloatKey_GetInterpolationMode_Params Parms{}; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneScriptingFloatKey.GetArriveTangentWeight // (Native, Public, BlueprintCallable, BlueprintPure, Const) // Parameters: // float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) float UMovieSceneScriptingFloatKey::GetArriveTangentWeight() { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingFloatKey", "GetArriveTangentWeight"); Params::UMovieSceneScriptingFloatKey_GetArriveTangentWeight_Params Parms{}; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneScriptingFloatKey.GetArriveTangent // (Native, Public, BlueprintCallable, BlueprintPure, Const) // Parameters: // float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) float UMovieSceneScriptingFloatKey::GetArriveTangent() { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingFloatKey", "GetArriveTangent"); Params::UMovieSceneScriptingFloatKey_GetArriveTangent_Params Parms{}; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Class SequencerScripting.MovieSceneScriptingActualFloatKey // (None) class UClass* UMovieSceneScriptingActualFloatKey::StaticClass() { static class UClass* Clss = nullptr; if (!Clss) Clss = UObject::FindClassFast("MovieSceneScriptingActualFloatKey"); return Clss; } // MovieSceneScriptingActualFloatKey SequencerScripting.Default__MovieSceneScriptingActualFloatKey // (Public, ClassDefaultObject, ArchetypeObject) class UMovieSceneScriptingActualFloatKey* UMovieSceneScriptingActualFloatKey::GetDefaultObj() { static class UMovieSceneScriptingActualFloatKey* Default = nullptr; if (!Default) Default = static_cast(UMovieSceneScriptingActualFloatKey::StaticClass()->DefaultObject); return Default; } // Class SequencerScripting.MovieSceneScriptingDoubleAsFloatKey // (None) class UClass* UMovieSceneScriptingDoubleAsFloatKey::StaticClass() { static class UClass* Clss = nullptr; if (!Clss) Clss = UObject::FindClassFast("MovieSceneScriptingDoubleAsFloatKey"); return Clss; } // MovieSceneScriptingDoubleAsFloatKey SequencerScripting.Default__MovieSceneScriptingDoubleAsFloatKey // (Public, ClassDefaultObject, ArchetypeObject) class UMovieSceneScriptingDoubleAsFloatKey* UMovieSceneScriptingDoubleAsFloatKey::GetDefaultObj() { static class UMovieSceneScriptingDoubleAsFloatKey* Default = nullptr; if (!Default) Default = static_cast(UMovieSceneScriptingDoubleAsFloatKey::StaticClass()->DefaultObject); return Default; } // Class SequencerScripting.MovieSceneScriptingFloatChannel // (None) class UClass* UMovieSceneScriptingFloatChannel::StaticClass() { static class UClass* Clss = nullptr; if (!Clss) Clss = UObject::FindClassFast("MovieSceneScriptingFloatChannel"); return Clss; } // MovieSceneScriptingFloatChannel SequencerScripting.Default__MovieSceneScriptingFloatChannel // (Public, ClassDefaultObject, ArchetypeObject) class UMovieSceneScriptingFloatChannel* UMovieSceneScriptingFloatChannel::GetDefaultObj() { static class UMovieSceneScriptingFloatChannel* Default = nullptr; if (!Default) Default = static_cast(UMovieSceneScriptingFloatChannel::StaticClass()->DefaultObject); return Default; } // Function SequencerScripting.MovieSceneScriptingFloatChannel.SetPreInfinityExtrapolation // (Final, Native, Public, BlueprintCallable) // Parameters: // enum class ERichCurveExtrapolation InExtrapolation (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) void UMovieSceneScriptingFloatChannel::SetPreInfinityExtrapolation(enum class ERichCurveExtrapolation InExtrapolation) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingFloatChannel", "SetPreInfinityExtrapolation"); Params::UMovieSceneScriptingFloatChannel_SetPreInfinityExtrapolation_Params Parms{}; Parms.InExtrapolation = InExtrapolation; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; } // Function SequencerScripting.MovieSceneScriptingFloatChannel.SetPostInfinityExtrapolation // (Final, Native, Public, BlueprintCallable) // Parameters: // enum class ERichCurveExtrapolation InExtrapolation (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) void UMovieSceneScriptingFloatChannel::SetPostInfinityExtrapolation(enum class ERichCurveExtrapolation InExtrapolation) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingFloatChannel", "SetPostInfinityExtrapolation"); Params::UMovieSceneScriptingFloatChannel_SetPostInfinityExtrapolation_Params Parms{}; Parms.InExtrapolation = InExtrapolation; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; } // Function SequencerScripting.MovieSceneScriptingFloatChannel.SetDefault // (Final, Native, Public, BlueprintCallable) // Parameters: // float InDefaultValue (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) void UMovieSceneScriptingFloatChannel::SetDefault(float InDefaultValue) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingFloatChannel", "SetDefault"); Params::UMovieSceneScriptingFloatChannel_SetDefault_Params Parms{}; Parms.InDefaultValue = InDefaultValue; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; } // Function SequencerScripting.MovieSceneScriptingFloatChannel.RemoveKey // (Native, Public, BlueprintCallable) // Parameters: // class UMovieSceneScriptingKey* Key (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) void UMovieSceneScriptingFloatChannel::RemoveKey(class UMovieSceneScriptingKey* Key) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingFloatChannel", "RemoveKey"); Params::UMovieSceneScriptingFloatChannel_RemoveKey_Params Parms{}; Parms.Key = Key; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; } // Function SequencerScripting.MovieSceneScriptingFloatChannel.RemoveDefault // (Final, Native, Public, BlueprintCallable) // Parameters: void UMovieSceneScriptingFloatChannel::RemoveDefault() { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingFloatChannel", "RemoveDefault"); auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, nullptr); Func->FunctionFlags = Flgs; } // Function SequencerScripting.MovieSceneScriptingFloatChannel.HasDefault // (Final, Native, Public, BlueprintCallable, BlueprintPure, Const) // Parameters: // bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) bool UMovieSceneScriptingFloatChannel::HasDefault() { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingFloatChannel", "HasDefault"); Params::UMovieSceneScriptingFloatChannel_HasDefault_Params Parms{}; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneScriptingFloatChannel.GetPreInfinityExtrapolation // (Final, Native, Public, BlueprintCallable, BlueprintPure, Const) // Parameters: // enum class ERichCurveExtrapolation ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) enum class ERichCurveExtrapolation UMovieSceneScriptingFloatChannel::GetPreInfinityExtrapolation() { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingFloatChannel", "GetPreInfinityExtrapolation"); Params::UMovieSceneScriptingFloatChannel_GetPreInfinityExtrapolation_Params Parms{}; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneScriptingFloatChannel.GetPostInfinityExtrapolation // (Final, Native, Public, BlueprintCallable, BlueprintPure, Const) // Parameters: // enum class ERichCurveExtrapolation ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) enum class ERichCurveExtrapolation UMovieSceneScriptingFloatChannel::GetPostInfinityExtrapolation() { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingFloatChannel", "GetPostInfinityExtrapolation"); Params::UMovieSceneScriptingFloatChannel_GetPostInfinityExtrapolation_Params Parms{}; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneScriptingFloatChannel.GetNumKeys // (Final, Native, Public, BlueprintCallable, BlueprintPure, Const) // Parameters: // int32 ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) int32 UMovieSceneScriptingFloatChannel::GetNumKeys() { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingFloatChannel", "GetNumKeys"); Params::UMovieSceneScriptingFloatChannel_GetNumKeys_Params Parms{}; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneScriptingFloatChannel.GetKeys // (Native, Public, BlueprintCallable, BlueprintPure, Const) // Parameters: // TArrayReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic) TArray UMovieSceneScriptingFloatChannel::GetKeys() { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingFloatChannel", "GetKeys"); Params::UMovieSceneScriptingFloatChannel_GetKeys_Params Parms{}; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneScriptingFloatChannel.GetDefault // (Final, Native, Public, BlueprintCallable, BlueprintPure, Const) // Parameters: // float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) float UMovieSceneScriptingFloatChannel::GetDefault() { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingFloatChannel", "GetDefault"); Params::UMovieSceneScriptingFloatChannel_GetDefault_Params Parms{}; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneScriptingFloatChannel.EvaluateKeys // (Final, Native, Public, BlueprintCallable, BlueprintPure, Const) // Parameters: // struct FSequencerScriptingRange Range (Parm, NoDestructor, NativeAccessSpecifierPublic) // struct FFrameRate FrameRate (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // TArray ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic) TArray UMovieSceneScriptingFloatChannel::EvaluateKeys(const struct FSequencerScriptingRange& Range, const struct FFrameRate& FrameRate) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingFloatChannel", "EvaluateKeys"); Params::UMovieSceneScriptingFloatChannel_EvaluateKeys_Params Parms{}; Parms.Range = Range; Parms.FrameRate = FrameRate; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneScriptingFloatChannel.ComputeEffectiveRange // (Final, Native, Public, BlueprintCallable, BlueprintPure, Const) // Parameters: // struct FSequencerScriptingRange ReturnValue (Parm, OutParm, ReturnParm, NoDestructor, NativeAccessSpecifierPublic) struct FSequencerScriptingRange UMovieSceneScriptingFloatChannel::ComputeEffectiveRange() { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingFloatChannel", "ComputeEffectiveRange"); Params::UMovieSceneScriptingFloatChannel_ComputeEffectiveRange_Params Parms{}; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneScriptingFloatChannel.AddKey // (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable) // Parameters: // struct FFrameNumber InTime (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // float NewValue (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // float SubFrame (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // enum class ESequenceTimeUnit TimeUnit (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // enum class EMovieSceneKeyInterpolationInInterpolation (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // class UMovieSceneScriptingFloatKey*ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) class UMovieSceneScriptingFloatKey* UMovieSceneScriptingFloatChannel::AddKey(struct FFrameNumber& InTime, float NewValue, float SubFrame, enum class ESequenceTimeUnit TimeUnit, enum class EMovieSceneKeyInterpolation InInterpolation) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingFloatChannel", "AddKey"); Params::UMovieSceneScriptingFloatChannel_AddKey_Params Parms{}; Parms.InTime = InTime; Parms.NewValue = NewValue; Parms.SubFrame = SubFrame; Parms.TimeUnit = TimeUnit; Parms.InInterpolation = InInterpolation; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Class SequencerScripting.MovieSceneScriptingIntegerKey // (None) class UClass* UMovieSceneScriptingIntegerKey::StaticClass() { static class UClass* Clss = nullptr; if (!Clss) Clss = UObject::FindClassFast("MovieSceneScriptingIntegerKey"); return Clss; } // MovieSceneScriptingIntegerKey SequencerScripting.Default__MovieSceneScriptingIntegerKey // (Public, ClassDefaultObject, ArchetypeObject) class UMovieSceneScriptingIntegerKey* UMovieSceneScriptingIntegerKey::GetDefaultObj() { static class UMovieSceneScriptingIntegerKey* Default = nullptr; if (!Default) Default = static_cast(UMovieSceneScriptingIntegerKey::StaticClass()->DefaultObject); return Default; } // Function SequencerScripting.MovieSceneScriptingIntegerKey.SetValue // (Final, Native, Public, BlueprintCallable) // Parameters: // int32 InNewValue (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) void UMovieSceneScriptingIntegerKey::SetValue(int32 InNewValue) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingIntegerKey", "SetValue"); Params::UMovieSceneScriptingIntegerKey_SetValue_Params Parms{}; Parms.InNewValue = InNewValue; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; } // Function SequencerScripting.MovieSceneScriptingIntegerKey.SetTime // (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable) // Parameters: // struct FFrameNumber NewFrameNumber (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // float SubFrame (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // enum class ESequenceTimeUnit TimeUnit (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) void UMovieSceneScriptingIntegerKey::SetTime(struct FFrameNumber& NewFrameNumber, float SubFrame, enum class ESequenceTimeUnit TimeUnit) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingIntegerKey", "SetTime"); Params::UMovieSceneScriptingIntegerKey_SetTime_Params Parms{}; Parms.NewFrameNumber = NewFrameNumber; Parms.SubFrame = SubFrame; Parms.TimeUnit = TimeUnit; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; } // Function SequencerScripting.MovieSceneScriptingIntegerKey.GetValue // (Final, Native, Public, BlueprintCallable, BlueprintPure, Const) // Parameters: // int32 ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) int32 UMovieSceneScriptingIntegerKey::GetValue() { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingIntegerKey", "GetValue"); Params::UMovieSceneScriptingIntegerKey_GetValue_Params Parms{}; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneScriptingIntegerKey.GetTime // (Native, Public, BlueprintCallable, BlueprintPure, Const) // Parameters: // enum class ESequenceTimeUnit TimeUnit (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // struct FFrameTime ReturnValue (Parm, OutParm, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) struct FFrameTime UMovieSceneScriptingIntegerKey::GetTime(enum class ESequenceTimeUnit TimeUnit) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingIntegerKey", "GetTime"); Params::UMovieSceneScriptingIntegerKey_GetTime_Params Parms{}; Parms.TimeUnit = TimeUnit; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Class SequencerScripting.MovieSceneScriptingIntegerChannel // (None) class UClass* UMovieSceneScriptingIntegerChannel::StaticClass() { static class UClass* Clss = nullptr; if (!Clss) Clss = UObject::FindClassFast("MovieSceneScriptingIntegerChannel"); return Clss; } // MovieSceneScriptingIntegerChannel SequencerScripting.Default__MovieSceneScriptingIntegerChannel // (Public, ClassDefaultObject, ArchetypeObject) class UMovieSceneScriptingIntegerChannel* UMovieSceneScriptingIntegerChannel::GetDefaultObj() { static class UMovieSceneScriptingIntegerChannel* Default = nullptr; if (!Default) Default = static_cast(UMovieSceneScriptingIntegerChannel::StaticClass()->DefaultObject); return Default; } // Function SequencerScripting.MovieSceneScriptingIntegerChannel.SetDefault // (Final, Native, Public, BlueprintCallable) // Parameters: // int32 InDefaultValue (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) void UMovieSceneScriptingIntegerChannel::SetDefault(int32 InDefaultValue) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingIntegerChannel", "SetDefault"); Params::UMovieSceneScriptingIntegerChannel_SetDefault_Params Parms{}; Parms.InDefaultValue = InDefaultValue; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; } // Function SequencerScripting.MovieSceneScriptingIntegerChannel.RemoveKey // (Native, Public, BlueprintCallable) // Parameters: // class UMovieSceneScriptingKey* Key (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) void UMovieSceneScriptingIntegerChannel::RemoveKey(class UMovieSceneScriptingKey* Key) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingIntegerChannel", "RemoveKey"); Params::UMovieSceneScriptingIntegerChannel_RemoveKey_Params Parms{}; Parms.Key = Key; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; } // Function SequencerScripting.MovieSceneScriptingIntegerChannel.RemoveDefault // (Final, Native, Public, BlueprintCallable) // Parameters: void UMovieSceneScriptingIntegerChannel::RemoveDefault() { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingIntegerChannel", "RemoveDefault"); auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, nullptr); Func->FunctionFlags = Flgs; } // Function SequencerScripting.MovieSceneScriptingIntegerChannel.HasDefault // (Final, Native, Public, BlueprintCallable, BlueprintPure, Const) // Parameters: // bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) bool UMovieSceneScriptingIntegerChannel::HasDefault() { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingIntegerChannel", "HasDefault"); Params::UMovieSceneScriptingIntegerChannel_HasDefault_Params Parms{}; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneScriptingIntegerChannel.GetKeys // (Native, Public, BlueprintCallable, BlueprintPure, Const) // Parameters: // TArrayReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic) TArray UMovieSceneScriptingIntegerChannel::GetKeys() { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingIntegerChannel", "GetKeys"); Params::UMovieSceneScriptingIntegerChannel_GetKeys_Params Parms{}; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneScriptingIntegerChannel.GetDefault // (Final, Native, Public, BlueprintCallable, BlueprintPure, Const) // Parameters: // int32 ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) int32 UMovieSceneScriptingIntegerChannel::GetDefault() { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingIntegerChannel", "GetDefault"); Params::UMovieSceneScriptingIntegerChannel_GetDefault_Params Parms{}; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneScriptingIntegerChannel.AddKey // (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable) // Parameters: // struct FFrameNumber InTime (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // int32 NewValue (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // float SubFrame (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // enum class ESequenceTimeUnit TimeUnit (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // class UMovieSceneScriptingIntegerKey*ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) class UMovieSceneScriptingIntegerKey* UMovieSceneScriptingIntegerChannel::AddKey(struct FFrameNumber& InTime, int32 NewValue, float SubFrame, enum class ESequenceTimeUnit TimeUnit) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingIntegerChannel", "AddKey"); Params::UMovieSceneScriptingIntegerChannel_AddKey_Params Parms{}; Parms.InTime = InTime; Parms.NewValue = NewValue; Parms.SubFrame = SubFrame; Parms.TimeUnit = TimeUnit; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Class SequencerScripting.MovieSceneScriptingObjectPathKey // (None) class UClass* UMovieSceneScriptingObjectPathKey::StaticClass() { static class UClass* Clss = nullptr; if (!Clss) Clss = UObject::FindClassFast("MovieSceneScriptingObjectPathKey"); return Clss; } // MovieSceneScriptingObjectPathKey SequencerScripting.Default__MovieSceneScriptingObjectPathKey // (Public, ClassDefaultObject, ArchetypeObject) class UMovieSceneScriptingObjectPathKey* UMovieSceneScriptingObjectPathKey::GetDefaultObj() { static class UMovieSceneScriptingObjectPathKey* Default = nullptr; if (!Default) Default = static_cast(UMovieSceneScriptingObjectPathKey::StaticClass()->DefaultObject); return Default; } // Function SequencerScripting.MovieSceneScriptingObjectPathKey.SetValue // (Final, Native, Public, BlueprintCallable) // Parameters: // class UObject* InNewValue (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) void UMovieSceneScriptingObjectPathKey::SetValue(class UObject* InNewValue) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingObjectPathKey", "SetValue"); Params::UMovieSceneScriptingObjectPathKey_SetValue_Params Parms{}; Parms.InNewValue = InNewValue; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; } // Function SequencerScripting.MovieSceneScriptingObjectPathKey.SetTime // (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable) // Parameters: // struct FFrameNumber NewFrameNumber (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // float SubFrame (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // enum class ESequenceTimeUnit TimeUnit (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) void UMovieSceneScriptingObjectPathKey::SetTime(struct FFrameNumber& NewFrameNumber, float SubFrame, enum class ESequenceTimeUnit TimeUnit) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingObjectPathKey", "SetTime"); Params::UMovieSceneScriptingObjectPathKey_SetTime_Params Parms{}; Parms.NewFrameNumber = NewFrameNumber; Parms.SubFrame = SubFrame; Parms.TimeUnit = TimeUnit; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; } // Function SequencerScripting.MovieSceneScriptingObjectPathKey.GetValue // (Final, Native, Public, BlueprintCallable, BlueprintPure, Const) // Parameters: // class UObject* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) class UObject* UMovieSceneScriptingObjectPathKey::GetValue() { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingObjectPathKey", "GetValue"); Params::UMovieSceneScriptingObjectPathKey_GetValue_Params Parms{}; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneScriptingObjectPathKey.GetTime // (Native, Public, BlueprintCallable, BlueprintPure, Const) // Parameters: // enum class ESequenceTimeUnit TimeUnit (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // struct FFrameTime ReturnValue (Parm, OutParm, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) struct FFrameTime UMovieSceneScriptingObjectPathKey::GetTime(enum class ESequenceTimeUnit TimeUnit) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingObjectPathKey", "GetTime"); Params::UMovieSceneScriptingObjectPathKey_GetTime_Params Parms{}; Parms.TimeUnit = TimeUnit; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Class SequencerScripting.MovieSceneScriptingObjectPathChannel // (None) class UClass* UMovieSceneScriptingObjectPathChannel::StaticClass() { static class UClass* Clss = nullptr; if (!Clss) Clss = UObject::FindClassFast("MovieSceneScriptingObjectPathChannel"); return Clss; } // MovieSceneScriptingObjectPathChannel SequencerScripting.Default__MovieSceneScriptingObjectPathChannel // (Public, ClassDefaultObject, ArchetypeObject) class UMovieSceneScriptingObjectPathChannel* UMovieSceneScriptingObjectPathChannel::GetDefaultObj() { static class UMovieSceneScriptingObjectPathChannel* Default = nullptr; if (!Default) Default = static_cast(UMovieSceneScriptingObjectPathChannel::StaticClass()->DefaultObject); return Default; } // Function SequencerScripting.MovieSceneScriptingObjectPathChannel.SetDefault // (Final, Native, Public, BlueprintCallable) // Parameters: // class UObject* InDefaultValue (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) void UMovieSceneScriptingObjectPathChannel::SetDefault(class UObject* InDefaultValue) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingObjectPathChannel", "SetDefault"); Params::UMovieSceneScriptingObjectPathChannel_SetDefault_Params Parms{}; Parms.InDefaultValue = InDefaultValue; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; } // Function SequencerScripting.MovieSceneScriptingObjectPathChannel.RemoveKey // (Native, Public, BlueprintCallable) // Parameters: // class UMovieSceneScriptingKey* Key (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) void UMovieSceneScriptingObjectPathChannel::RemoveKey(class UMovieSceneScriptingKey* Key) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingObjectPathChannel", "RemoveKey"); Params::UMovieSceneScriptingObjectPathChannel_RemoveKey_Params Parms{}; Parms.Key = Key; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; } // Function SequencerScripting.MovieSceneScriptingObjectPathChannel.RemoveDefault // (Final, Native, Public, BlueprintCallable) // Parameters: void UMovieSceneScriptingObjectPathChannel::RemoveDefault() { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingObjectPathChannel", "RemoveDefault"); auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, nullptr); Func->FunctionFlags = Flgs; } // Function SequencerScripting.MovieSceneScriptingObjectPathChannel.HasDefault // (Final, Native, Public, BlueprintCallable, BlueprintPure, Const) // Parameters: // bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) bool UMovieSceneScriptingObjectPathChannel::HasDefault() { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingObjectPathChannel", "HasDefault"); Params::UMovieSceneScriptingObjectPathChannel_HasDefault_Params Parms{}; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneScriptingObjectPathChannel.GetKeys // (Native, Public, BlueprintCallable, BlueprintPure, Const) // Parameters: // TArrayReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic) TArray UMovieSceneScriptingObjectPathChannel::GetKeys() { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingObjectPathChannel", "GetKeys"); Params::UMovieSceneScriptingObjectPathChannel_GetKeys_Params Parms{}; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneScriptingObjectPathChannel.GetDefault // (Final, Native, Public, BlueprintCallable, BlueprintPure, Const) // Parameters: // class UObject* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) class UObject* UMovieSceneScriptingObjectPathChannel::GetDefault() { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingObjectPathChannel", "GetDefault"); Params::UMovieSceneScriptingObjectPathChannel_GetDefault_Params Parms{}; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneScriptingObjectPathChannel.AddKey // (Final, Native, Public, HasDefaults, BlueprintCallable) // Parameters: // struct FFrameNumber InTime (ConstParm, Parm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // class UObject* NewValue (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // float SubFrame (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // enum class ESequenceTimeUnit TimeUnit (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // class UMovieSceneScriptingObjectPathKey*ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) class UMovieSceneScriptingObjectPathKey* UMovieSceneScriptingObjectPathChannel::AddKey(const struct FFrameNumber& InTime, class UObject* NewValue, float SubFrame, enum class ESequenceTimeUnit TimeUnit) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingObjectPathChannel", "AddKey"); Params::UMovieSceneScriptingObjectPathChannel_AddKey_Params Parms{}; Parms.InTime = InTime; Parms.NewValue = NewValue; Parms.SubFrame = SubFrame; Parms.TimeUnit = TimeUnit; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Class SequencerScripting.MovieSceneScriptingStringKey // (None) class UClass* UMovieSceneScriptingStringKey::StaticClass() { static class UClass* Clss = nullptr; if (!Clss) Clss = UObject::FindClassFast("MovieSceneScriptingStringKey"); return Clss; } // MovieSceneScriptingStringKey SequencerScripting.Default__MovieSceneScriptingStringKey // (Public, ClassDefaultObject, ArchetypeObject) class UMovieSceneScriptingStringKey* UMovieSceneScriptingStringKey::GetDefaultObj() { static class UMovieSceneScriptingStringKey* Default = nullptr; if (!Default) Default = static_cast(UMovieSceneScriptingStringKey::StaticClass()->DefaultObject); return Default; } // Function SequencerScripting.MovieSceneScriptingStringKey.SetValue // (Final, Native, Public, BlueprintCallable) // Parameters: // class FString InNewValue (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) void UMovieSceneScriptingStringKey::SetValue(const class FString& InNewValue) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingStringKey", "SetValue"); Params::UMovieSceneScriptingStringKey_SetValue_Params Parms{}; Parms.InNewValue = InNewValue; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; } // Function SequencerScripting.MovieSceneScriptingStringKey.SetTime // (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable) // Parameters: // struct FFrameNumber NewFrameNumber (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // float SubFrame (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // enum class ESequenceTimeUnit TimeUnit (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) void UMovieSceneScriptingStringKey::SetTime(struct FFrameNumber& NewFrameNumber, float SubFrame, enum class ESequenceTimeUnit TimeUnit) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingStringKey", "SetTime"); Params::UMovieSceneScriptingStringKey_SetTime_Params Parms{}; Parms.NewFrameNumber = NewFrameNumber; Parms.SubFrame = SubFrame; Parms.TimeUnit = TimeUnit; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; } // Function SequencerScripting.MovieSceneScriptingStringKey.GetValue // (Final, Native, Public, BlueprintCallable, BlueprintPure, Const) // Parameters: // class FString ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic) class FString UMovieSceneScriptingStringKey::GetValue() { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingStringKey", "GetValue"); Params::UMovieSceneScriptingStringKey_GetValue_Params Parms{}; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneScriptingStringKey.GetTime // (Native, Public, BlueprintCallable, BlueprintPure, Const) // Parameters: // enum class ESequenceTimeUnit TimeUnit (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // struct FFrameTime ReturnValue (Parm, OutParm, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) struct FFrameTime UMovieSceneScriptingStringKey::GetTime(enum class ESequenceTimeUnit TimeUnit) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingStringKey", "GetTime"); Params::UMovieSceneScriptingStringKey_GetTime_Params Parms{}; Parms.TimeUnit = TimeUnit; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Class SequencerScripting.MovieSceneScriptingStringChannel // (None) class UClass* UMovieSceneScriptingStringChannel::StaticClass() { static class UClass* Clss = nullptr; if (!Clss) Clss = UObject::FindClassFast("MovieSceneScriptingStringChannel"); return Clss; } // MovieSceneScriptingStringChannel SequencerScripting.Default__MovieSceneScriptingStringChannel // (Public, ClassDefaultObject, ArchetypeObject) class UMovieSceneScriptingStringChannel* UMovieSceneScriptingStringChannel::GetDefaultObj() { static class UMovieSceneScriptingStringChannel* Default = nullptr; if (!Default) Default = static_cast(UMovieSceneScriptingStringChannel::StaticClass()->DefaultObject); return Default; } // Function SequencerScripting.MovieSceneScriptingStringChannel.SetDefault // (Final, Native, Public, BlueprintCallable) // Parameters: // class FString InDefaultValue (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) void UMovieSceneScriptingStringChannel::SetDefault(const class FString& InDefaultValue) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingStringChannel", "SetDefault"); Params::UMovieSceneScriptingStringChannel_SetDefault_Params Parms{}; Parms.InDefaultValue = InDefaultValue; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; } // Function SequencerScripting.MovieSceneScriptingStringChannel.RemoveKey // (Native, Public, BlueprintCallable) // Parameters: // class UMovieSceneScriptingKey* Key (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) void UMovieSceneScriptingStringChannel::RemoveKey(class UMovieSceneScriptingKey* Key) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingStringChannel", "RemoveKey"); Params::UMovieSceneScriptingStringChannel_RemoveKey_Params Parms{}; Parms.Key = Key; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; } // Function SequencerScripting.MovieSceneScriptingStringChannel.RemoveDefault // (Final, Native, Public, BlueprintCallable) // Parameters: void UMovieSceneScriptingStringChannel::RemoveDefault() { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingStringChannel", "RemoveDefault"); auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, nullptr); Func->FunctionFlags = Flgs; } // Function SequencerScripting.MovieSceneScriptingStringChannel.HasDefault // (Final, Native, Public, BlueprintCallable, BlueprintPure, Const) // Parameters: // bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) bool UMovieSceneScriptingStringChannel::HasDefault() { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingStringChannel", "HasDefault"); Params::UMovieSceneScriptingStringChannel_HasDefault_Params Parms{}; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneScriptingStringChannel.GetKeys // (Native, Public, BlueprintCallable, BlueprintPure, Const) // Parameters: // TArrayReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic) TArray UMovieSceneScriptingStringChannel::GetKeys() { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingStringChannel", "GetKeys"); Params::UMovieSceneScriptingStringChannel_GetKeys_Params Parms{}; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneScriptingStringChannel.GetDefault // (Final, Native, Public, BlueprintCallable, BlueprintPure, Const) // Parameters: // class FString ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic) class FString UMovieSceneScriptingStringChannel::GetDefault() { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingStringChannel", "GetDefault"); Params::UMovieSceneScriptingStringChannel_GetDefault_Params Parms{}; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneScriptingStringChannel.AddKey // (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable) // Parameters: // struct FFrameNumber InTime (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // class FString NewValue (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // float SubFrame (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // enum class ESequenceTimeUnit TimeUnit (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // class UMovieSceneScriptingStringKey*ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) class UMovieSceneScriptingStringKey* UMovieSceneScriptingStringChannel::AddKey(struct FFrameNumber& InTime, const class FString& NewValue, float SubFrame, enum class ESequenceTimeUnit TimeUnit) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneScriptingStringChannel", "AddKey"); Params::UMovieSceneScriptingStringChannel_AddKey_Params Parms{}; Parms.InTime = InTime; Parms.NewValue = NewValue; Parms.SubFrame = SubFrame; Parms.TimeUnit = TimeUnit; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Class SequencerScripting.MovieSceneBindingExtensions // (None) class UClass* UMovieSceneBindingExtensions::StaticClass() { static class UClass* Clss = nullptr; if (!Clss) Clss = UObject::FindClassFast("MovieSceneBindingExtensions"); return Clss; } // MovieSceneBindingExtensions SequencerScripting.Default__MovieSceneBindingExtensions // (Public, ClassDefaultObject, ArchetypeObject) class UMovieSceneBindingExtensions* UMovieSceneBindingExtensions::GetDefaultObj() { static class UMovieSceneBindingExtensions* Default = nullptr; if (!Default) Default = static_cast(UMovieSceneBindingExtensions::StaticClass()->DefaultObject); return Default; } // Function SequencerScripting.MovieSceneBindingExtensions.SetParent // (Final, Native, Static, Public, HasOutParams, BlueprintCallable) // Parameters: // struct FMovieSceneBindingProxy InBinding (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic) // struct FMovieSceneBindingProxy InParentBinding (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic) void UMovieSceneBindingExtensions::SetParent(struct FMovieSceneBindingProxy& InBinding, struct FMovieSceneBindingProxy& InParentBinding) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneBindingExtensions", "SetParent"); Params::UMovieSceneBindingExtensions_SetParent_Params Parms{}; Parms.InBinding = InBinding; Parms.InParentBinding = InParentBinding; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; } // Function SequencerScripting.MovieSceneBindingExtensions.SetName // (Final, Native, Static, Public, HasOutParams, BlueprintCallable) // Parameters: // struct FMovieSceneBindingProxy InBinding (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic) // class FString InName (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) void UMovieSceneBindingExtensions::SetName(struct FMovieSceneBindingProxy& InBinding, const class FString& InName) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneBindingExtensions", "SetName"); Params::UMovieSceneBindingExtensions_SetName_Params Parms{}; Parms.InBinding = InBinding; Parms.InName = InName; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; } // Function SequencerScripting.MovieSceneBindingExtensions.SetDisplayName // (Final, Native, Static, Public, HasOutParams, BlueprintCallable) // Parameters: // struct FMovieSceneBindingProxy InBinding (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic) // class FText InDisplayName (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic) void UMovieSceneBindingExtensions::SetDisplayName(struct FMovieSceneBindingProxy& InBinding, class FText& InDisplayName) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneBindingExtensions", "SetDisplayName"); Params::UMovieSceneBindingExtensions_SetDisplayName_Params Parms{}; Parms.InBinding = InBinding; Parms.InDisplayName = InDisplayName; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; } // Function SequencerScripting.MovieSceneBindingExtensions.RemoveTrack // (Final, Native, Static, Public, HasOutParams, BlueprintCallable) // Parameters: // struct FMovieSceneBindingProxy InBinding (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic) // class UMovieSceneTrack* TrackToRemove (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) void UMovieSceneBindingExtensions::RemoveTrack(struct FMovieSceneBindingProxy& InBinding, class UMovieSceneTrack* TrackToRemove) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneBindingExtensions", "RemoveTrack"); Params::UMovieSceneBindingExtensions_RemoveTrack_Params Parms{}; Parms.InBinding = InBinding; Parms.TrackToRemove = TrackToRemove; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; } // Function SequencerScripting.MovieSceneBindingExtensions.Remove // (Final, Native, Static, Public, HasOutParams, BlueprintCallable) // Parameters: // struct FMovieSceneBindingProxy InBinding (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic) void UMovieSceneBindingExtensions::Remove(struct FMovieSceneBindingProxy& InBinding) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneBindingExtensions", "Remove"); Params::UMovieSceneBindingExtensions_Remove_Params Parms{}; Parms.InBinding = InBinding; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; } // Function SequencerScripting.MovieSceneBindingExtensions.MoveBindingContents // (Final, Native, Static, Public, HasOutParams, BlueprintCallable) // Parameters: // struct FMovieSceneBindingProxy SourceBindingId (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic) // struct FMovieSceneBindingProxy DestinationBindingId (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic) void UMovieSceneBindingExtensions::MoveBindingContents(struct FMovieSceneBindingProxy& SourceBindingId, struct FMovieSceneBindingProxy& DestinationBindingId) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneBindingExtensions", "MoveBindingContents"); Params::UMovieSceneBindingExtensions_MoveBindingContents_Params Parms{}; Parms.SourceBindingId = SourceBindingId; Parms.DestinationBindingId = DestinationBindingId; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; } // Function SequencerScripting.MovieSceneBindingExtensions.IsValid // (Final, Native, Static, Public, HasOutParams, BlueprintCallable, BlueprintPure) // Parameters: // struct FMovieSceneBindingProxy InBinding (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic) // bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) bool UMovieSceneBindingExtensions::IsValid(struct FMovieSceneBindingProxy& InBinding) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneBindingExtensions", "IsValid"); Params::UMovieSceneBindingExtensions_IsValid_Params Parms{}; Parms.InBinding = InBinding; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneBindingExtensions.GetTracks // (Final, Native, Static, Public, HasOutParams, BlueprintCallable) // Parameters: // struct FMovieSceneBindingProxy InBinding (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic) // TArray ReturnValue (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, ContainsInstancedReference, NativeAccessSpecifierPublic) TArray UMovieSceneBindingExtensions::GetTracks(struct FMovieSceneBindingProxy& InBinding) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneBindingExtensions", "GetTracks"); Params::UMovieSceneBindingExtensions_GetTracks_Params Parms{}; Parms.InBinding = InBinding; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneBindingExtensions.GetPossessedObjectClass // (Final, Native, Static, Public, HasOutParams, BlueprintCallable) // Parameters: // struct FMovieSceneBindingProxy InBinding (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic) // class UClass* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) class UClass* UMovieSceneBindingExtensions::GetPossessedObjectClass(struct FMovieSceneBindingProxy& InBinding) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneBindingExtensions", "GetPossessedObjectClass"); Params::UMovieSceneBindingExtensions_GetPossessedObjectClass_Params Parms{}; Parms.InBinding = InBinding; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneBindingExtensions.GetParent // (Final, Native, Static, Public, HasOutParams, BlueprintCallable) // Parameters: // struct FMovieSceneBindingProxy InBinding (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic) // struct FMovieSceneBindingProxy ReturnValue (Parm, OutParm, ReturnParm, NoDestructor, NativeAccessSpecifierPublic) struct FMovieSceneBindingProxy UMovieSceneBindingExtensions::GetParent(struct FMovieSceneBindingProxy& InBinding) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneBindingExtensions", "GetParent"); Params::UMovieSceneBindingExtensions_GetParent_Params Parms{}; Parms.InBinding = InBinding; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneBindingExtensions.GetObjectTemplate // (Final, Native, Static, Public, HasOutParams, BlueprintCallable) // Parameters: // struct FMovieSceneBindingProxy InBinding (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic) // class UObject* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) class UObject* UMovieSceneBindingExtensions::GetObjectTemplate(struct FMovieSceneBindingProxy& InBinding) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneBindingExtensions", "GetObjectTemplate"); Params::UMovieSceneBindingExtensions_GetObjectTemplate_Params Parms{}; Parms.InBinding = InBinding; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneBindingExtensions.GetName // (Final, Native, Static, Public, HasOutParams, BlueprintCallable) // Parameters: // struct FMovieSceneBindingProxy InBinding (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic) // class FString ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic) class FString UMovieSceneBindingExtensions::GetName(struct FMovieSceneBindingProxy& InBinding) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneBindingExtensions", "GetName"); Params::UMovieSceneBindingExtensions_GetName_Params Parms{}; Parms.InBinding = InBinding; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneBindingExtensions.GetId // (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable) // Parameters: // struct FMovieSceneBindingProxy InBinding (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic) // struct FGuid ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) struct FGuid UMovieSceneBindingExtensions::GetId(struct FMovieSceneBindingProxy& InBinding) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneBindingExtensions", "GetId"); Params::UMovieSceneBindingExtensions_GetId_Params Parms{}; Parms.InBinding = InBinding; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneBindingExtensions.GetDisplayName // (Final, Native, Static, Public, HasOutParams, BlueprintCallable) // Parameters: // struct FMovieSceneBindingProxy InBinding (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic) // class FText ReturnValue (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic) class FText UMovieSceneBindingExtensions::GetDisplayName(struct FMovieSceneBindingProxy& InBinding) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneBindingExtensions", "GetDisplayName"); Params::UMovieSceneBindingExtensions_GetDisplayName_Params Parms{}; Parms.InBinding = InBinding; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneBindingExtensions.GetChildPossessables // (Final, Native, Static, Public, HasOutParams, BlueprintCallable) // Parameters: // struct FMovieSceneBindingProxy InBinding (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic) // TArrayReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic) TArray UMovieSceneBindingExtensions::GetChildPossessables(struct FMovieSceneBindingProxy& InBinding) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneBindingExtensions", "GetChildPossessables"); Params::UMovieSceneBindingExtensions_GetChildPossessables_Params Parms{}; Parms.InBinding = InBinding; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneBindingExtensions.FindTracksByType // (Final, Native, Static, Public, HasOutParams, BlueprintCallable) // Parameters: // struct FMovieSceneBindingProxy InBinding (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic) // TSubclassOfTrackType (Parm, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic) // TArray ReturnValue (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, ContainsInstancedReference, NativeAccessSpecifierPublic) TArray UMovieSceneBindingExtensions::FindTracksByType(struct FMovieSceneBindingProxy& InBinding, TSubclassOf TrackType) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneBindingExtensions", "FindTracksByType"); Params::UMovieSceneBindingExtensions_FindTracksByType_Params Parms{}; Parms.InBinding = InBinding; Parms.TrackType = TrackType; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneBindingExtensions.FindTracksByExactType // (Final, Native, Static, Public, HasOutParams, BlueprintCallable) // Parameters: // struct FMovieSceneBindingProxy InBinding (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic) // TSubclassOfTrackType (Parm, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic) // TArray ReturnValue (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, ContainsInstancedReference, NativeAccessSpecifierPublic) TArray UMovieSceneBindingExtensions::FindTracksByExactType(struct FMovieSceneBindingProxy& InBinding, TSubclassOf TrackType) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneBindingExtensions", "FindTracksByExactType"); Params::UMovieSceneBindingExtensions_FindTracksByExactType_Params Parms{}; Parms.InBinding = InBinding; Parms.TrackType = TrackType; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneBindingExtensions.AddTrack // (Final, Native, Static, Public, HasOutParams, BlueprintCallable) // Parameters: // struct FMovieSceneBindingProxy InBinding (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic) // TSubclassOfTrackType (Parm, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic) // class UMovieSceneTrack* ReturnValue (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) class UMovieSceneTrack* UMovieSceneBindingExtensions::AddTrack(struct FMovieSceneBindingProxy& InBinding, TSubclassOf TrackType) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneBindingExtensions", "AddTrack"); Params::UMovieSceneBindingExtensions_AddTrack_Params Parms{}; Parms.InBinding = InBinding; Parms.TrackType = TrackType; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Class SequencerScripting.MovieSceneEventTrackExtensions // (None) class UClass* UMovieSceneEventTrackExtensions::StaticClass() { static class UClass* Clss = nullptr; if (!Clss) Clss = UObject::FindClassFast("MovieSceneEventTrackExtensions"); return Clss; } // MovieSceneEventTrackExtensions SequencerScripting.Default__MovieSceneEventTrackExtensions // (Public, ClassDefaultObject, ArchetypeObject) class UMovieSceneEventTrackExtensions* UMovieSceneEventTrackExtensions::GetDefaultObj() { static class UMovieSceneEventTrackExtensions* Default = nullptr; if (!Default) Default = static_cast(UMovieSceneEventTrackExtensions::StaticClass()->DefaultObject); return Default; } // Function SequencerScripting.MovieSceneEventTrackExtensions.GetBoundObjectPropertyClass // (Final, Native, Static, Public, HasOutParams, BlueprintCallable) // Parameters: // struct FMovieSceneEvent EventKey (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic) // class UClass* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) class UClass* UMovieSceneEventTrackExtensions::GetBoundObjectPropertyClass(struct FMovieSceneEvent& EventKey) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneEventTrackExtensions", "GetBoundObjectPropertyClass"); Params::UMovieSceneEventTrackExtensions_GetBoundObjectPropertyClass_Params Parms{}; Parms.EventKey = EventKey; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneEventTrackExtensions.AddEventTriggerSection // (Final, Native, Static, Public, BlueprintCallable) // Parameters: // class UMovieSceneEventTrack* InTrack (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // class UMovieSceneEventTriggerSection*ReturnValue (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) class UMovieSceneEventTriggerSection* UMovieSceneEventTrackExtensions::AddEventTriggerSection(class UMovieSceneEventTrack* InTrack) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneEventTrackExtensions", "AddEventTriggerSection"); Params::UMovieSceneEventTrackExtensions_AddEventTriggerSection_Params Parms{}; Parms.InTrack = InTrack; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneEventTrackExtensions.AddEventRepeaterSection // (Final, Native, Static, Public, BlueprintCallable) // Parameters: // class UMovieSceneEventTrack* InTrack (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // class UMovieSceneEventRepeaterSection*ReturnValue (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) class UMovieSceneEventRepeaterSection* UMovieSceneEventTrackExtensions::AddEventRepeaterSection(class UMovieSceneEventTrack* InTrack) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneEventTrackExtensions", "AddEventRepeaterSection"); Params::UMovieSceneEventTrackExtensions_AddEventRepeaterSection_Params Parms{}; Parms.InTrack = InTrack; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Class SequencerScripting.MovieSceneFolderExtensions // (None) class UClass* UMovieSceneFolderExtensions::StaticClass() { static class UClass* Clss = nullptr; if (!Clss) Clss = UObject::FindClassFast("MovieSceneFolderExtensions"); return Clss; } // MovieSceneFolderExtensions SequencerScripting.Default__MovieSceneFolderExtensions // (Public, ClassDefaultObject, ArchetypeObject) class UMovieSceneFolderExtensions* UMovieSceneFolderExtensions::GetDefaultObj() { static class UMovieSceneFolderExtensions* Default = nullptr; if (!Default) Default = static_cast(UMovieSceneFolderExtensions::StaticClass()->DefaultObject); return Default; } // Function SequencerScripting.MovieSceneFolderExtensions.SetFolderName // (Final, Native, Static, Public, BlueprintCallable) // Parameters: // class UMovieSceneFolder* Folder (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // class FName InFolderName (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) bool UMovieSceneFolderExtensions::SetFolderName(class UMovieSceneFolder* Folder, class FName InFolderName) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneFolderExtensions", "SetFolderName"); Params::UMovieSceneFolderExtensions_SetFolderName_Params Parms{}; Parms.Folder = Folder; Parms.InFolderName = InFolderName; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneFolderExtensions.SetFolderColor // (Final, Native, Static, Public, HasDefaults, BlueprintCallable) // Parameters: // class UMovieSceneFolder* Folder (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // struct FColor InFolderColor (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) bool UMovieSceneFolderExtensions::SetFolderColor(class UMovieSceneFolder* Folder, const struct FColor& InFolderColor) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneFolderExtensions", "SetFolderColor"); Params::UMovieSceneFolderExtensions_SetFolderColor_Params Parms{}; Parms.Folder = Folder; Parms.InFolderColor = InFolderColor; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneFolderExtensions.RemoveChildObjectBinding // (Final, Native, Static, Public, BlueprintCallable) // Parameters: // class UMovieSceneFolder* Folder (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // struct FMovieSceneBindingProxy InObjectBinding (ConstParm, Parm, NoDestructor, NativeAccessSpecifierPublic) // bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) bool UMovieSceneFolderExtensions::RemoveChildObjectBinding(class UMovieSceneFolder* Folder, const struct FMovieSceneBindingProxy& InObjectBinding) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneFolderExtensions", "RemoveChildObjectBinding"); Params::UMovieSceneFolderExtensions_RemoveChildObjectBinding_Params Parms{}; Parms.Folder = Folder; Parms.InObjectBinding = InObjectBinding; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneFolderExtensions.RemoveChildMasterTrack // (Final, Native, Static, Public, BlueprintCallable) // Parameters: // class UMovieSceneFolder* Folder (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // class UMovieSceneTrack* InMasterTrack (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) bool UMovieSceneFolderExtensions::RemoveChildMasterTrack(class UMovieSceneFolder* Folder, class UMovieSceneTrack* InMasterTrack) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneFolderExtensions", "RemoveChildMasterTrack"); Params::UMovieSceneFolderExtensions_RemoveChildMasterTrack_Params Parms{}; Parms.Folder = Folder; Parms.InMasterTrack = InMasterTrack; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneFolderExtensions.RemoveChildFolder // (Final, Native, Static, Public, BlueprintCallable) // Parameters: // class UMovieSceneFolder* TargetFolder (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // class UMovieSceneFolder* FolderToRemove (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) bool UMovieSceneFolderExtensions::RemoveChildFolder(class UMovieSceneFolder* TargetFolder, class UMovieSceneFolder* FolderToRemove) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneFolderExtensions", "RemoveChildFolder"); Params::UMovieSceneFolderExtensions_RemoveChildFolder_Params Parms{}; Parms.TargetFolder = TargetFolder; Parms.FolderToRemove = FolderToRemove; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneFolderExtensions.GetFolderName // (Final, Native, Static, Public, BlueprintCallable, BlueprintPure) // Parameters: // class UMovieSceneFolder* Folder (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // class FName ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) class FName UMovieSceneFolderExtensions::GetFolderName(class UMovieSceneFolder* Folder) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneFolderExtensions", "GetFolderName"); Params::UMovieSceneFolderExtensions_GetFolderName_Params Parms{}; Parms.Folder = Folder; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneFolderExtensions.GetFolderColor // (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure) // Parameters: // class UMovieSceneFolder* Folder (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // struct FColor ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) struct FColor UMovieSceneFolderExtensions::GetFolderColor(class UMovieSceneFolder* Folder) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneFolderExtensions", "GetFolderColor"); Params::UMovieSceneFolderExtensions_GetFolderColor_Params Parms{}; Parms.Folder = Folder; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneFolderExtensions.GetChildObjectBindings // (Final, Native, Static, Public, BlueprintCallable, BlueprintPure) // Parameters: // class UMovieSceneFolder* Folder (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // TArrayReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic) TArray UMovieSceneFolderExtensions::GetChildObjectBindings(class UMovieSceneFolder* Folder) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneFolderExtensions", "GetChildObjectBindings"); Params::UMovieSceneFolderExtensions_GetChildObjectBindings_Params Parms{}; Parms.Folder = Folder; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneFolderExtensions.GetChildMasterTracks // (Final, Native, Static, Public, BlueprintCallable, BlueprintPure) // Parameters: // class UMovieSceneFolder* Folder (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // TArray ReturnValue (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, ContainsInstancedReference, NativeAccessSpecifierPublic) TArray UMovieSceneFolderExtensions::GetChildMasterTracks(class UMovieSceneFolder* Folder) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneFolderExtensions", "GetChildMasterTracks"); Params::UMovieSceneFolderExtensions_GetChildMasterTracks_Params Parms{}; Parms.Folder = Folder; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneFolderExtensions.GetChildFolders // (Final, Native, Static, Public, BlueprintCallable, BlueprintPure) // Parameters: // class UMovieSceneFolder* Folder (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // TArray ReturnValue (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, ContainsInstancedReference, NativeAccessSpecifierPublic) TArray UMovieSceneFolderExtensions::GetChildFolders(class UMovieSceneFolder* Folder) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneFolderExtensions", "GetChildFolders"); Params::UMovieSceneFolderExtensions_GetChildFolders_Params Parms{}; Parms.Folder = Folder; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneFolderExtensions.AddChildObjectBinding // (Final, Native, Static, Public, BlueprintCallable) // Parameters: // class UMovieSceneFolder* Folder (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // struct FMovieSceneBindingProxy InObjectBinding (Parm, NoDestructor, NativeAccessSpecifierPublic) // bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) bool UMovieSceneFolderExtensions::AddChildObjectBinding(class UMovieSceneFolder* Folder, const struct FMovieSceneBindingProxy& InObjectBinding) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneFolderExtensions", "AddChildObjectBinding"); Params::UMovieSceneFolderExtensions_AddChildObjectBinding_Params Parms{}; Parms.Folder = Folder; Parms.InObjectBinding = InObjectBinding; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneFolderExtensions.AddChildMasterTrack // (Final, Native, Static, Public, BlueprintCallable) // Parameters: // class UMovieSceneFolder* Folder (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // class UMovieSceneTrack* InMasterTrack (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) bool UMovieSceneFolderExtensions::AddChildMasterTrack(class UMovieSceneFolder* Folder, class UMovieSceneTrack* InMasterTrack) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneFolderExtensions", "AddChildMasterTrack"); Params::UMovieSceneFolderExtensions_AddChildMasterTrack_Params Parms{}; Parms.Folder = Folder; Parms.InMasterTrack = InMasterTrack; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneFolderExtensions.AddChildFolder // (Final, Native, Static, Public, BlueprintCallable) // Parameters: // class UMovieSceneFolder* TargetFolder (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // class UMovieSceneFolder* FolderToAdd (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) bool UMovieSceneFolderExtensions::AddChildFolder(class UMovieSceneFolder* TargetFolder, class UMovieSceneFolder* FolderToAdd) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneFolderExtensions", "AddChildFolder"); Params::UMovieSceneFolderExtensions_AddChildFolder_Params Parms{}; Parms.TargetFolder = TargetFolder; Parms.FolderToAdd = FolderToAdd; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Class SequencerScripting.MovieSceneMaterialTrackExtensions // (None) class UClass* UMovieSceneMaterialTrackExtensions::StaticClass() { static class UClass* Clss = nullptr; if (!Clss) Clss = UObject::FindClassFast("MovieSceneMaterialTrackExtensions"); return Clss; } // MovieSceneMaterialTrackExtensions SequencerScripting.Default__MovieSceneMaterialTrackExtensions // (Public, ClassDefaultObject, ArchetypeObject) class UMovieSceneMaterialTrackExtensions* UMovieSceneMaterialTrackExtensions::GetDefaultObj() { static class UMovieSceneMaterialTrackExtensions* Default = nullptr; if (!Default) Default = static_cast(UMovieSceneMaterialTrackExtensions::StaticClass()->DefaultObject); return Default; } // Function SequencerScripting.MovieSceneMaterialTrackExtensions.SetMaterialIndex // (Final, Native, Static, Public, BlueprintCallable) // Parameters: // class UMovieSceneComponentMaterialTrack*Track (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // int32 MaterialIndex (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) void UMovieSceneMaterialTrackExtensions::SetMaterialIndex(class UMovieSceneComponentMaterialTrack* Track, int32 MaterialIndex) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneMaterialTrackExtensions", "SetMaterialIndex"); Params::UMovieSceneMaterialTrackExtensions_SetMaterialIndex_Params Parms{}; Parms.Track = Track; Parms.MaterialIndex = MaterialIndex; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; } // Function SequencerScripting.MovieSceneMaterialTrackExtensions.GetMaterialIndex // (Final, Native, Static, Public, BlueprintCallable) // Parameters: // class UMovieSceneComponentMaterialTrack*Track (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // int32 ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) int32 UMovieSceneMaterialTrackExtensions::GetMaterialIndex(class UMovieSceneComponentMaterialTrack* Track) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneMaterialTrackExtensions", "GetMaterialIndex"); Params::UMovieSceneMaterialTrackExtensions_GetMaterialIndex_Params Parms{}; Parms.Track = Track; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Class SequencerScripting.MovieScenePrimitiveMaterialTrackExtensions // (None) class UClass* UMovieScenePrimitiveMaterialTrackExtensions::StaticClass() { static class UClass* Clss = nullptr; if (!Clss) Clss = UObject::FindClassFast("MovieScenePrimitiveMaterialTrackExtensions"); return Clss; } // MovieScenePrimitiveMaterialTrackExtensions SequencerScripting.Default__MovieScenePrimitiveMaterialTrackExtensions // (Public, ClassDefaultObject, ArchetypeObject) class UMovieScenePrimitiveMaterialTrackExtensions* UMovieScenePrimitiveMaterialTrackExtensions::GetDefaultObj() { static class UMovieScenePrimitiveMaterialTrackExtensions* Default = nullptr; if (!Default) Default = static_cast(UMovieScenePrimitiveMaterialTrackExtensions::StaticClass()->DefaultObject); return Default; } // Function SequencerScripting.MovieScenePrimitiveMaterialTrackExtensions.SetMaterialIndex // (Final, Native, Static, Public, BlueprintCallable) // Parameters: // class UMovieScenePrimitiveMaterialTrack*Track (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // int32 MaterialIndex (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) void UMovieScenePrimitiveMaterialTrackExtensions::SetMaterialIndex(class UMovieScenePrimitiveMaterialTrack* Track, int32 MaterialIndex) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieScenePrimitiveMaterialTrackExtensions", "SetMaterialIndex"); Params::UMovieScenePrimitiveMaterialTrackExtensions_SetMaterialIndex_Params Parms{}; Parms.Track = Track; Parms.MaterialIndex = MaterialIndex; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; } // Function SequencerScripting.MovieScenePrimitiveMaterialTrackExtensions.GetMaterialIndex // (Final, Native, Static, Public, BlueprintCallable) // Parameters: // class UMovieScenePrimitiveMaterialTrack*Track (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // int32 ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) int32 UMovieScenePrimitiveMaterialTrackExtensions::GetMaterialIndex(class UMovieScenePrimitiveMaterialTrack* Track) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieScenePrimitiveMaterialTrackExtensions", "GetMaterialIndex"); Params::UMovieScenePrimitiveMaterialTrackExtensions_GetMaterialIndex_Params Parms{}; Parms.Track = Track; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Class SequencerScripting.MovieScenePropertyTrackExtensions // (None) class UClass* UMovieScenePropertyTrackExtensions::StaticClass() { static class UClass* Clss = nullptr; if (!Clss) Clss = UObject::FindClassFast("MovieScenePropertyTrackExtensions"); return Clss; } // MovieScenePropertyTrackExtensions SequencerScripting.Default__MovieScenePropertyTrackExtensions // (Public, ClassDefaultObject, ArchetypeObject) class UMovieScenePropertyTrackExtensions* UMovieScenePropertyTrackExtensions::GetDefaultObj() { static class UMovieScenePropertyTrackExtensions* Default = nullptr; if (!Default) Default = static_cast(UMovieScenePropertyTrackExtensions::StaticClass()->DefaultObject); return Default; } // Function SequencerScripting.MovieScenePropertyTrackExtensions.SetPropertyNameAndPath // (Final, Native, Static, Public, HasOutParams, BlueprintCallable) // Parameters: // class UMovieScenePropertyTrack* Track (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // class FName InPropertyName (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // class FString InPropertyPath (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) void UMovieScenePropertyTrackExtensions::SetPropertyNameAndPath(class UMovieScenePropertyTrack* Track, class FName& InPropertyName, const class FString& InPropertyPath) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieScenePropertyTrackExtensions", "SetPropertyNameAndPath"); Params::UMovieScenePropertyTrackExtensions_SetPropertyNameAndPath_Params Parms{}; Parms.Track = Track; Parms.InPropertyName = InPropertyName; Parms.InPropertyPath = InPropertyPath; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; } // Function SequencerScripting.MovieScenePropertyTrackExtensions.SetObjectPropertyClass // (Final, Native, Static, Public, BlueprintCallable) // Parameters: // class UMovieSceneObjectPropertyTrack*Track (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // class UClass* PropertyClass (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) void UMovieScenePropertyTrackExtensions::SetObjectPropertyClass(class UMovieSceneObjectPropertyTrack* Track, class UClass* PropertyClass) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieScenePropertyTrackExtensions", "SetObjectPropertyClass"); Params::UMovieScenePropertyTrackExtensions_SetObjectPropertyClass_Params Parms{}; Parms.Track = Track; Parms.PropertyClass = PropertyClass; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; } // Function SequencerScripting.MovieScenePropertyTrackExtensions.SetByteTrackEnum // (Final, Native, Static, Public, BlueprintCallable) // Parameters: // class UMovieSceneByteTrack* Track (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // class UEnum* InEnum (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) void UMovieScenePropertyTrackExtensions::SetByteTrackEnum(class UMovieSceneByteTrack* Track, class UEnum* InEnum) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieScenePropertyTrackExtensions", "SetByteTrackEnum"); Params::UMovieScenePropertyTrackExtensions_SetByteTrackEnum_Params Parms{}; Parms.Track = Track; Parms.InEnum = InEnum; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; } // Function SequencerScripting.MovieScenePropertyTrackExtensions.GetUniqueTrackName // (Final, Native, Static, Public, BlueprintCallable) // Parameters: // class UMovieScenePropertyTrack* Track (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // class FName ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) class FName UMovieScenePropertyTrackExtensions::GetUniqueTrackName(class UMovieScenePropertyTrack* Track) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieScenePropertyTrackExtensions", "GetUniqueTrackName"); Params::UMovieScenePropertyTrackExtensions_GetUniqueTrackName_Params Parms{}; Parms.Track = Track; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieScenePropertyTrackExtensions.GetPropertyPath // (Final, Native, Static, Public, BlueprintCallable) // Parameters: // class UMovieScenePropertyTrack* Track (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // class FString ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic) class FString UMovieScenePropertyTrackExtensions::GetPropertyPath(class UMovieScenePropertyTrack* Track) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieScenePropertyTrackExtensions", "GetPropertyPath"); Params::UMovieScenePropertyTrackExtensions_GetPropertyPath_Params Parms{}; Parms.Track = Track; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieScenePropertyTrackExtensions.GetPropertyName // (Final, Native, Static, Public, BlueprintCallable) // Parameters: // class UMovieScenePropertyTrack* Track (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // class FName ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) class FName UMovieScenePropertyTrackExtensions::GetPropertyName(class UMovieScenePropertyTrack* Track) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieScenePropertyTrackExtensions", "GetPropertyName"); Params::UMovieScenePropertyTrackExtensions_GetPropertyName_Params Parms{}; Parms.Track = Track; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieScenePropertyTrackExtensions.GetObjectPropertyClass // (Final, Native, Static, Public, BlueprintCallable) // Parameters: // class UMovieSceneObjectPropertyTrack*Track (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // class UClass* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) class UClass* UMovieScenePropertyTrackExtensions::GetObjectPropertyClass(class UMovieSceneObjectPropertyTrack* Track) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieScenePropertyTrackExtensions", "GetObjectPropertyClass"); Params::UMovieScenePropertyTrackExtensions_GetObjectPropertyClass_Params Parms{}; Parms.Track = Track; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieScenePropertyTrackExtensions.GetByteTrackEnum // (Final, Native, Static, Public, BlueprintCallable, BlueprintPure) // Parameters: // class UMovieSceneByteTrack* Track (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // class UEnum* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) class UEnum* UMovieScenePropertyTrackExtensions::GetByteTrackEnum(class UMovieSceneByteTrack* Track) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieScenePropertyTrackExtensions", "GetByteTrackEnum"); Params::UMovieScenePropertyTrackExtensions_GetByteTrackEnum_Params Parms{}; Parms.Track = Track; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Class SequencerScripting.MovieSceneSectionExtensions // (None) class UClass* UMovieSceneSectionExtensions::StaticClass() { static class UClass* Clss = nullptr; if (!Clss) Clss = UObject::FindClassFast("MovieSceneSectionExtensions"); return Clss; } // MovieSceneSectionExtensions SequencerScripting.Default__MovieSceneSectionExtensions // (Public, ClassDefaultObject, ArchetypeObject) class UMovieSceneSectionExtensions* UMovieSceneSectionExtensions::GetDefaultObj() { static class UMovieSceneSectionExtensions* Default = nullptr; if (!Default) Default = static_cast(UMovieSceneSectionExtensions::StaticClass()->DefaultObject); return Default; } // Function SequencerScripting.MovieSceneSectionExtensions.SetStartFrameSeconds // (Final, Native, Static, Public, BlueprintCallable) // Parameters: // class UMovieSceneSection* Section (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // float StartTime (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) void UMovieSceneSectionExtensions::SetStartFrameSeconds(class UMovieSceneSection* Section, float StartTime) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneSectionExtensions", "SetStartFrameSeconds"); Params::UMovieSceneSectionExtensions_SetStartFrameSeconds_Params Parms{}; Parms.Section = Section; Parms.StartTime = StartTime; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; } // Function SequencerScripting.MovieSceneSectionExtensions.SetStartFrameBounded // (Final, Native, Static, Public, BlueprintCallable) // Parameters: // class UMovieSceneSection* Section (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // bool bIsBounded (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) void UMovieSceneSectionExtensions::SetStartFrameBounded(class UMovieSceneSection* Section, bool bIsBounded) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneSectionExtensions", "SetStartFrameBounded"); Params::UMovieSceneSectionExtensions_SetStartFrameBounded_Params Parms{}; Parms.Section = Section; Parms.bIsBounded = bIsBounded; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; } // Function SequencerScripting.MovieSceneSectionExtensions.SetStartFrame // (Final, Native, Static, Public, BlueprintCallable) // Parameters: // class UMovieSceneSection* Section (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // int32 StartFrame (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) void UMovieSceneSectionExtensions::SetStartFrame(class UMovieSceneSection* Section, int32 StartFrame) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneSectionExtensions", "SetStartFrame"); Params::UMovieSceneSectionExtensions_SetStartFrame_Params Parms{}; Parms.Section = Section; Parms.StartFrame = StartFrame; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; } // Function SequencerScripting.MovieSceneSectionExtensions.SetRangeSeconds // (Final, Native, Static, Public, BlueprintCallable) // Parameters: // class UMovieSceneSection* Section (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // float StartTime (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // float EndTime (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) void UMovieSceneSectionExtensions::SetRangeSeconds(class UMovieSceneSection* Section, float StartTime, float EndTime) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneSectionExtensions", "SetRangeSeconds"); Params::UMovieSceneSectionExtensions_SetRangeSeconds_Params Parms{}; Parms.Section = Section; Parms.StartTime = StartTime; Parms.EndTime = EndTime; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; } // Function SequencerScripting.MovieSceneSectionExtensions.SetRange // (Final, Native, Static, Public, BlueprintCallable) // Parameters: // class UMovieSceneSection* Section (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // int32 StartFrame (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // int32 EndFrame (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) void UMovieSceneSectionExtensions::SetRange(class UMovieSceneSection* Section, int32 StartFrame, int32 EndFrame) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneSectionExtensions", "SetRange"); Params::UMovieSceneSectionExtensions_SetRange_Params Parms{}; Parms.Section = Section; Parms.StartFrame = StartFrame; Parms.EndFrame = EndFrame; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; } // Function SequencerScripting.MovieSceneSectionExtensions.SetEndFrameSeconds // (Final, Native, Static, Public, BlueprintCallable) // Parameters: // class UMovieSceneSection* Section (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // float EndTime (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) void UMovieSceneSectionExtensions::SetEndFrameSeconds(class UMovieSceneSection* Section, float EndTime) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneSectionExtensions", "SetEndFrameSeconds"); Params::UMovieSceneSectionExtensions_SetEndFrameSeconds_Params Parms{}; Parms.Section = Section; Parms.EndTime = EndTime; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; } // Function SequencerScripting.MovieSceneSectionExtensions.SetEndFrameBounded // (Final, Native, Static, Public, BlueprintCallable) // Parameters: // class UMovieSceneSection* Section (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // bool bIsBounded (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) void UMovieSceneSectionExtensions::SetEndFrameBounded(class UMovieSceneSection* Section, bool bIsBounded) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneSectionExtensions", "SetEndFrameBounded"); Params::UMovieSceneSectionExtensions_SetEndFrameBounded_Params Parms{}; Parms.Section = Section; Parms.bIsBounded = bIsBounded; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; } // Function SequencerScripting.MovieSceneSectionExtensions.SetEndFrame // (Final, Native, Static, Public, BlueprintCallable) // Parameters: // class UMovieSceneSection* Section (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // int32 EndFrame (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) void UMovieSceneSectionExtensions::SetEndFrame(class UMovieSceneSection* Section, int32 EndFrame) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneSectionExtensions", "SetEndFrame"); Params::UMovieSceneSectionExtensions_SetEndFrame_Params Parms{}; Parms.Section = Section; Parms.EndFrame = EndFrame; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; } // Function SequencerScripting.MovieSceneSectionExtensions.HasStartFrame // (Final, Native, Static, Public, BlueprintCallable) // Parameters: // class UMovieSceneSection* Section (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) bool UMovieSceneSectionExtensions::HasStartFrame(class UMovieSceneSection* Section) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneSectionExtensions", "HasStartFrame"); Params::UMovieSceneSectionExtensions_HasStartFrame_Params Parms{}; Parms.Section = Section; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneSectionExtensions.HasEndFrame // (Final, Native, Static, Public, BlueprintCallable) // Parameters: // class UMovieSceneSection* Section (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) bool UMovieSceneSectionExtensions::HasEndFrame(class UMovieSceneSection* Section) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneSectionExtensions", "HasEndFrame"); Params::UMovieSceneSectionExtensions_HasEndFrame_Params Parms{}; Parms.Section = Section; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneSectionExtensions.GetStartFrameSeconds // (Final, Native, Static, Public, BlueprintCallable) // Parameters: // class UMovieSceneSection* Section (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) float UMovieSceneSectionExtensions::GetStartFrameSeconds(class UMovieSceneSection* Section) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneSectionExtensions", "GetStartFrameSeconds"); Params::UMovieSceneSectionExtensions_GetStartFrameSeconds_Params Parms{}; Parms.Section = Section; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneSectionExtensions.GetStartFrame // (Final, Native, Static, Public, BlueprintCallable) // Parameters: // class UMovieSceneSection* Section (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // int32 ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) int32 UMovieSceneSectionExtensions::GetStartFrame(class UMovieSceneSection* Section) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneSectionExtensions", "GetStartFrame"); Params::UMovieSceneSectionExtensions_GetStartFrame_Params Parms{}; Parms.Section = Section; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneSectionExtensions.GetParentSequenceFrame // (Final, Native, Static, Public, BlueprintCallable) // Parameters: // class UMovieSceneSubSection* Section (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // int32 InFrame (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // class UMovieSceneSequence* ParentSequence (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // int32 ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) int32 UMovieSceneSectionExtensions::GetParentSequenceFrame(class UMovieSceneSubSection* Section, int32 InFrame, class UMovieSceneSequence* ParentSequence) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneSectionExtensions", "GetParentSequenceFrame"); Params::UMovieSceneSectionExtensions_GetParentSequenceFrame_Params Parms{}; Parms.Section = Section; Parms.InFrame = InFrame; Parms.ParentSequence = ParentSequence; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneSectionExtensions.GetEndFrameSeconds // (Final, Native, Static, Public, BlueprintCallable) // Parameters: // class UMovieSceneSection* Section (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) float UMovieSceneSectionExtensions::GetEndFrameSeconds(class UMovieSceneSection* Section) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneSectionExtensions", "GetEndFrameSeconds"); Params::UMovieSceneSectionExtensions_GetEndFrameSeconds_Params Parms{}; Parms.Section = Section; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneSectionExtensions.GetEndFrame // (Final, Native, Static, Public, BlueprintCallable) // Parameters: // class UMovieSceneSection* Section (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // int32 ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) int32 UMovieSceneSectionExtensions::GetEndFrame(class UMovieSceneSection* Section) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneSectionExtensions", "GetEndFrame"); Params::UMovieSceneSectionExtensions_GetEndFrame_Params Parms{}; Parms.Section = Section; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneSectionExtensions.GetChannelsByType // (Final, Native, Static, Public, BlueprintCallable) // Parameters: // class UMovieSceneSection* Section (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // TSubclassOfChannelType (Parm, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic) // TArrayReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic) TArray UMovieSceneSectionExtensions::GetChannelsByType(class UMovieSceneSection* Section, TSubclassOf ChannelType) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneSectionExtensions", "GetChannelsByType"); Params::UMovieSceneSectionExtensions_GetChannelsByType_Params Parms{}; Parms.Section = Section; Parms.ChannelType = ChannelType; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneSectionExtensions.GetChannels // (Final, Native, Static, Public, BlueprintCallable) // Parameters: // class UMovieSceneSection* Section (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // TArrayReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic) TArray UMovieSceneSectionExtensions::GetChannels(class UMovieSceneSection* Section) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneSectionExtensions", "GetChannels"); Params::UMovieSceneSectionExtensions_GetChannels_Params Parms{}; Parms.Section = Section; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneSectionExtensions.GetAutoSizeStartFrameSeconds // (Final, Native, Static, Public, BlueprintCallable) // Parameters: // class UMovieSceneSection* Section (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) float UMovieSceneSectionExtensions::GetAutoSizeStartFrameSeconds(class UMovieSceneSection* Section) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneSectionExtensions", "GetAutoSizeStartFrameSeconds"); Params::UMovieSceneSectionExtensions_GetAutoSizeStartFrameSeconds_Params Parms{}; Parms.Section = Section; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneSectionExtensions.GetAutoSizeStartFrame // (Final, Native, Static, Public, BlueprintCallable) // Parameters: // class UMovieSceneSection* Section (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // int32 ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) int32 UMovieSceneSectionExtensions::GetAutoSizeStartFrame(class UMovieSceneSection* Section) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneSectionExtensions", "GetAutoSizeStartFrame"); Params::UMovieSceneSectionExtensions_GetAutoSizeStartFrame_Params Parms{}; Parms.Section = Section; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneSectionExtensions.GetAutoSizeHasStartFrame // (Final, Native, Static, Public, BlueprintCallable) // Parameters: // class UMovieSceneSection* Section (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) bool UMovieSceneSectionExtensions::GetAutoSizeHasStartFrame(class UMovieSceneSection* Section) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneSectionExtensions", "GetAutoSizeHasStartFrame"); Params::UMovieSceneSectionExtensions_GetAutoSizeHasStartFrame_Params Parms{}; Parms.Section = Section; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneSectionExtensions.GetAutoSizeHasEndFrame // (Final, Native, Static, Public, BlueprintCallable) // Parameters: // class UMovieSceneSection* Section (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) bool UMovieSceneSectionExtensions::GetAutoSizeHasEndFrame(class UMovieSceneSection* Section) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneSectionExtensions", "GetAutoSizeHasEndFrame"); Params::UMovieSceneSectionExtensions_GetAutoSizeHasEndFrame_Params Parms{}; Parms.Section = Section; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneSectionExtensions.GetAutoSizeEndFrameSeconds // (Final, Native, Static, Public, BlueprintCallable) // Parameters: // class UMovieSceneSection* Section (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) float UMovieSceneSectionExtensions::GetAutoSizeEndFrameSeconds(class UMovieSceneSection* Section) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneSectionExtensions", "GetAutoSizeEndFrameSeconds"); Params::UMovieSceneSectionExtensions_GetAutoSizeEndFrameSeconds_Params Parms{}; Parms.Section = Section; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneSectionExtensions.GetAutoSizeEndFrame // (Final, Native, Static, Public, BlueprintCallable) // Parameters: // class UMovieSceneSection* Section (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // int32 ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) int32 UMovieSceneSectionExtensions::GetAutoSizeEndFrame(class UMovieSceneSection* Section) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneSectionExtensions", "GetAutoSizeEndFrame"); Params::UMovieSceneSectionExtensions_GetAutoSizeEndFrame_Params Parms{}; Parms.Section = Section; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneSectionExtensions.GetAllChannels // (Final, Native, Static, Public, BlueprintCallable) // Parameters: // class UMovieSceneSection* Section (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // TArrayReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic) TArray UMovieSceneSectionExtensions::GetAllChannels(class UMovieSceneSection* Section) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneSectionExtensions", "GetAllChannels"); Params::UMovieSceneSectionExtensions_GetAllChannels_Params Parms{}; Parms.Section = Section; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneSectionExtensions.FindChannelsByType // (Final, Native, Static, Public, BlueprintCallable) // Parameters: // class UMovieSceneSection* Section (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // TSubclassOfChannelType (Parm, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic) // TArrayReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic) TArray UMovieSceneSectionExtensions::FindChannelsByType(class UMovieSceneSection* Section, TSubclassOf ChannelType) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneSectionExtensions", "FindChannelsByType"); Params::UMovieSceneSectionExtensions_FindChannelsByType_Params Parms{}; Parms.Section = Section; Parms.ChannelType = ChannelType; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Class SequencerScripting.MovieSceneSequenceExtensions // (None) class UClass* UMovieSceneSequenceExtensions::StaticClass() { static class UClass* Clss = nullptr; if (!Clss) Clss = UObject::FindClassFast("MovieSceneSequenceExtensions"); return Clss; } // MovieSceneSequenceExtensions SequencerScripting.Default__MovieSceneSequenceExtensions // (Public, ClassDefaultObject, ArchetypeObject) class UMovieSceneSequenceExtensions* UMovieSceneSequenceExtensions::GetDefaultObj() { static class UMovieSceneSequenceExtensions* Default = nullptr; if (!Default) Default = static_cast(UMovieSceneSequenceExtensions::StaticClass()->DefaultObject); return Default; } // Function SequencerScripting.MovieSceneSequenceExtensions.SortMarkedFrames // (Final, Native, Static, Public, BlueprintCallable) // Parameters: // class UMovieSceneSequence* Sequence (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) void UMovieSceneSequenceExtensions::SortMarkedFrames(class UMovieSceneSequence* Sequence) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneSequenceExtensions", "SortMarkedFrames"); Params::UMovieSceneSequenceExtensions_SortMarkedFrames_Params Parms{}; Parms.Sequence = Sequence; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; } // Function SequencerScripting.MovieSceneSequenceExtensions.SetWorkRangeStart // (Final, Native, Static, Public, BlueprintCallable) // Parameters: // class UMovieSceneSequence* InSequence (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // float StartTimeInSeconds (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) void UMovieSceneSequenceExtensions::SetWorkRangeStart(class UMovieSceneSequence* InSequence, float StartTimeInSeconds) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneSequenceExtensions", "SetWorkRangeStart"); Params::UMovieSceneSequenceExtensions_SetWorkRangeStart_Params Parms{}; Parms.InSequence = InSequence; Parms.StartTimeInSeconds = StartTimeInSeconds; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; } // Function SequencerScripting.MovieSceneSequenceExtensions.SetWorkRangeEnd // (Final, Native, Static, Public, BlueprintCallable) // Parameters: // class UMovieSceneSequence* InSequence (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // float EndTimeInSeconds (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) void UMovieSceneSequenceExtensions::SetWorkRangeEnd(class UMovieSceneSequence* InSequence, float EndTimeInSeconds) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneSequenceExtensions", "SetWorkRangeEnd"); Params::UMovieSceneSequenceExtensions_SetWorkRangeEnd_Params Parms{}; Parms.InSequence = InSequence; Parms.EndTimeInSeconds = EndTimeInSeconds; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; } // Function SequencerScripting.MovieSceneSequenceExtensions.SetViewRangeStart // (Final, Native, Static, Public, BlueprintCallable) // Parameters: // class UMovieSceneSequence* InSequence (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // float StartTimeInSeconds (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) void UMovieSceneSequenceExtensions::SetViewRangeStart(class UMovieSceneSequence* InSequence, float StartTimeInSeconds) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneSequenceExtensions", "SetViewRangeStart"); Params::UMovieSceneSequenceExtensions_SetViewRangeStart_Params Parms{}; Parms.InSequence = InSequence; Parms.StartTimeInSeconds = StartTimeInSeconds; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; } // Function SequencerScripting.MovieSceneSequenceExtensions.SetViewRangeEnd // (Final, Native, Static, Public, BlueprintCallable) // Parameters: // class UMovieSceneSequence* InSequence (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // float EndTimeInSeconds (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) void UMovieSceneSequenceExtensions::SetViewRangeEnd(class UMovieSceneSequence* InSequence, float EndTimeInSeconds) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneSequenceExtensions", "SetViewRangeEnd"); Params::UMovieSceneSequenceExtensions_SetViewRangeEnd_Params Parms{}; Parms.InSequence = InSequence; Parms.EndTimeInSeconds = EndTimeInSeconds; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; } // Function SequencerScripting.MovieSceneSequenceExtensions.SetTickResolutionDirectly // (Final, Native, Static, Public, BlueprintCallable) // Parameters: // class UMovieSceneSequence* Sequence (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // struct FFrameRate TickResolution (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) void UMovieSceneSequenceExtensions::SetTickResolutionDirectly(class UMovieSceneSequence* Sequence, const struct FFrameRate& TickResolution) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneSequenceExtensions", "SetTickResolutionDirectly"); Params::UMovieSceneSequenceExtensions_SetTickResolutionDirectly_Params Parms{}; Parms.Sequence = Sequence; Parms.TickResolution = TickResolution; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; } // Function SequencerScripting.MovieSceneSequenceExtensions.SetTickResolution // (Final, Native, Static, Public, BlueprintCallable) // Parameters: // class UMovieSceneSequence* Sequence (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // struct FFrameRate TickResolution (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) void UMovieSceneSequenceExtensions::SetTickResolution(class UMovieSceneSequence* Sequence, const struct FFrameRate& TickResolution) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneSequenceExtensions", "SetTickResolution"); Params::UMovieSceneSequenceExtensions_SetTickResolution_Params Parms{}; Parms.Sequence = Sequence; Parms.TickResolution = TickResolution; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; } // Function SequencerScripting.MovieSceneSequenceExtensions.SetReadOnly // (Final, Native, Static, Public, BlueprintCallable) // Parameters: // class UMovieSceneSequence* Sequence (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // bool bInReadOnly (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) void UMovieSceneSequenceExtensions::SetReadOnly(class UMovieSceneSequence* Sequence, bool bInReadOnly) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneSequenceExtensions", "SetReadOnly"); Params::UMovieSceneSequenceExtensions_SetReadOnly_Params Parms{}; Parms.Sequence = Sequence; Parms.bInReadOnly = bInReadOnly; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; } // Function SequencerScripting.MovieSceneSequenceExtensions.SetPlaybackStartSeconds // (Final, Native, Static, Public, BlueprintCallable) // Parameters: // class UMovieSceneSequence* Sequence (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // float StartTime (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) void UMovieSceneSequenceExtensions::SetPlaybackStartSeconds(class UMovieSceneSequence* Sequence, float StartTime) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneSequenceExtensions", "SetPlaybackStartSeconds"); Params::UMovieSceneSequenceExtensions_SetPlaybackStartSeconds_Params Parms{}; Parms.Sequence = Sequence; Parms.StartTime = StartTime; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; } // Function SequencerScripting.MovieSceneSequenceExtensions.SetPlaybackStart // (Final, Native, Static, Public, BlueprintCallable) // Parameters: // class UMovieSceneSequence* Sequence (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // int32 StartFrame (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) void UMovieSceneSequenceExtensions::SetPlaybackStart(class UMovieSceneSequence* Sequence, int32 StartFrame) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneSequenceExtensions", "SetPlaybackStart"); Params::UMovieSceneSequenceExtensions_SetPlaybackStart_Params Parms{}; Parms.Sequence = Sequence; Parms.StartFrame = StartFrame; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; } // Function SequencerScripting.MovieSceneSequenceExtensions.SetPlaybackEndSeconds // (Final, Native, Static, Public, BlueprintCallable) // Parameters: // class UMovieSceneSequence* Sequence (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // float EndTime (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) void UMovieSceneSequenceExtensions::SetPlaybackEndSeconds(class UMovieSceneSequence* Sequence, float EndTime) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneSequenceExtensions", "SetPlaybackEndSeconds"); Params::UMovieSceneSequenceExtensions_SetPlaybackEndSeconds_Params Parms{}; Parms.Sequence = Sequence; Parms.EndTime = EndTime; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; } // Function SequencerScripting.MovieSceneSequenceExtensions.SetPlaybackEnd // (Final, Native, Static, Public, BlueprintCallable) // Parameters: // class UMovieSceneSequence* Sequence (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // int32 EndFrame (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) void UMovieSceneSequenceExtensions::SetPlaybackEnd(class UMovieSceneSequence* Sequence, int32 EndFrame) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneSequenceExtensions", "SetPlaybackEnd"); Params::UMovieSceneSequenceExtensions_SetPlaybackEnd_Params Parms{}; Parms.Sequence = Sequence; Parms.EndFrame = EndFrame; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; } // Function SequencerScripting.MovieSceneSequenceExtensions.SetMarkedFrame // (Final, Native, Static, Public, HasDefaults, BlueprintCallable) // Parameters: // class UMovieSceneSequence* Sequence (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // int32 InMarkIndex (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // struct FFrameNumber InFrameNumber (Parm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) void UMovieSceneSequenceExtensions::SetMarkedFrame(class UMovieSceneSequence* Sequence, int32 InMarkIndex, const struct FFrameNumber& InFrameNumber) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneSequenceExtensions", "SetMarkedFrame"); Params::UMovieSceneSequenceExtensions_SetMarkedFrame_Params Parms{}; Parms.Sequence = Sequence; Parms.InMarkIndex = InMarkIndex; Parms.InFrameNumber = InFrameNumber; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; } // Function SequencerScripting.MovieSceneSequenceExtensions.SetEvaluationType // (Final, Native, Static, Public, BlueprintCallable) // Parameters: // class UMovieSceneSequence* InSequence (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // enum class EMovieSceneEvaluationTypeInEvaluationType (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) void UMovieSceneSequenceExtensions::SetEvaluationType(class UMovieSceneSequence* InSequence, enum class EMovieSceneEvaluationType InEvaluationType) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneSequenceExtensions", "SetEvaluationType"); Params::UMovieSceneSequenceExtensions_SetEvaluationType_Params Parms{}; Parms.InSequence = InSequence; Parms.InEvaluationType = InEvaluationType; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; } // Function SequencerScripting.MovieSceneSequenceExtensions.SetDisplayRate // (Final, Native, Static, Public, BlueprintCallable) // Parameters: // class UMovieSceneSequence* Sequence (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // struct FFrameRate DisplayRate (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) void UMovieSceneSequenceExtensions::SetDisplayRate(class UMovieSceneSequence* Sequence, const struct FFrameRate& DisplayRate) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneSequenceExtensions", "SetDisplayRate"); Params::UMovieSceneSequenceExtensions_SetDisplayRate_Params Parms{}; Parms.Sequence = Sequence; Parms.DisplayRate = DisplayRate; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; } // Function SequencerScripting.MovieSceneSequenceExtensions.SetClockSource // (Final, Native, Static, Public, BlueprintCallable) // Parameters: // class UMovieSceneSequence* InSequence (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // enum class EUpdateClockSource InClockSource (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) void UMovieSceneSequenceExtensions::SetClockSource(class UMovieSceneSequence* InSequence, enum class EUpdateClockSource InClockSource) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneSequenceExtensions", "SetClockSource"); Params::UMovieSceneSequenceExtensions_SetClockSource_Params Parms{}; Parms.InSequence = InSequence; Parms.InClockSource = InClockSource; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; } // Function SequencerScripting.MovieSceneSequenceExtensions.ResolveBindingID // (Final, Native, Static, Public, BlueprintCallable) // Parameters: // class UMovieSceneSequence* MasterSequence (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // struct FMovieSceneObjectBindingID InObjectBindingID (Parm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // struct FMovieSceneBindingProxy ReturnValue (Parm, OutParm, ReturnParm, NoDestructor, NativeAccessSpecifierPublic) struct FMovieSceneBindingProxy UMovieSceneSequenceExtensions::ResolveBindingID(class UMovieSceneSequence* MasterSequence, const struct FMovieSceneObjectBindingID& InObjectBindingID) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneSequenceExtensions", "ResolveBindingID"); Params::UMovieSceneSequenceExtensions_ResolveBindingID_Params Parms{}; Parms.MasterSequence = MasterSequence; Parms.InObjectBindingID = InObjectBindingID; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneSequenceExtensions.RemoveRootFolderFromSequence // (Final, Native, Static, Public, BlueprintCallable) // Parameters: // class UMovieSceneSequence* Sequence (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // class UMovieSceneFolder* Folder (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) void UMovieSceneSequenceExtensions::RemoveRootFolderFromSequence(class UMovieSceneSequence* Sequence, class UMovieSceneFolder* Folder) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneSequenceExtensions", "RemoveRootFolderFromSequence"); Params::UMovieSceneSequenceExtensions_RemoveRootFolderFromSequence_Params Parms{}; Parms.Sequence = Sequence; Parms.Folder = Folder; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; } // Function SequencerScripting.MovieSceneSequenceExtensions.RemoveMasterTrack // (Final, Native, Static, Public, BlueprintCallable) // Parameters: // class UMovieSceneSequence* Sequence (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // class UMovieSceneTrack* MasterTrack (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) bool UMovieSceneSequenceExtensions::RemoveMasterTrack(class UMovieSceneSequence* Sequence, class UMovieSceneTrack* MasterTrack) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneSequenceExtensions", "RemoveMasterTrack"); Params::UMovieSceneSequenceExtensions_RemoveMasterTrack_Params Parms{}; Parms.Sequence = Sequence; Parms.MasterTrack = MasterTrack; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneSequenceExtensions.MakeRangeSeconds // (Final, Native, Static, Public, BlueprintCallable) // Parameters: // class UMovieSceneSequence* Sequence (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // float StartTime (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // float Duration (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // struct FSequencerScriptingRange ReturnValue (Parm, OutParm, ReturnParm, NoDestructor, NativeAccessSpecifierPublic) struct FSequencerScriptingRange UMovieSceneSequenceExtensions::MakeRangeSeconds(class UMovieSceneSequence* Sequence, float StartTime, float Duration) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneSequenceExtensions", "MakeRangeSeconds"); Params::UMovieSceneSequenceExtensions_MakeRangeSeconds_Params Parms{}; Parms.Sequence = Sequence; Parms.StartTime = StartTime; Parms.Duration = Duration; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneSequenceExtensions.MakeRange // (Final, Native, Static, Public, BlueprintCallable) // Parameters: // class UMovieSceneSequence* Sequence (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // int32 StartFrame (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // int32 Duration (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // struct FSequencerScriptingRange ReturnValue (Parm, OutParm, ReturnParm, NoDestructor, NativeAccessSpecifierPublic) struct FSequencerScriptingRange UMovieSceneSequenceExtensions::MakeRange(class UMovieSceneSequence* Sequence, int32 StartFrame, int32 Duration) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneSequenceExtensions", "MakeRange"); Params::UMovieSceneSequenceExtensions_MakeRange_Params Parms{}; Parms.Sequence = Sequence; Parms.StartFrame = StartFrame; Parms.Duration = Duration; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneSequenceExtensions.MakeBindingID // (Final, Native, Static, Public, HasOutParams, BlueprintCallable) // Parameters: // class UMovieSceneSequence* MasterSequence (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // struct FMovieSceneBindingProxy InBinding (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic) // enum class EMovieSceneObjectBindingSpaceSpace (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // struct FMovieSceneObjectBindingID ReturnValue (Parm, OutParm, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) struct FMovieSceneObjectBindingID UMovieSceneSequenceExtensions::MakeBindingID(class UMovieSceneSequence* MasterSequence, struct FMovieSceneBindingProxy& InBinding, enum class EMovieSceneObjectBindingSpace Space) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneSequenceExtensions", "MakeBindingID"); Params::UMovieSceneSequenceExtensions_MakeBindingID_Params Parms{}; Parms.MasterSequence = MasterSequence; Parms.InBinding = InBinding; Parms.Space = Space; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneSequenceExtensions.LocateBoundObjects // (Final, Native, Static, Public, HasOutParams, BlueprintCallable) // Parameters: // class UMovieSceneSequence* Sequence (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // struct FMovieSceneBindingProxy InBinding (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic) // class UObject* Context (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // TArray ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic) TArray UMovieSceneSequenceExtensions::LocateBoundObjects(class UMovieSceneSequence* Sequence, struct FMovieSceneBindingProxy& InBinding, class UObject* Context) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneSequenceExtensions", "LocateBoundObjects"); Params::UMovieSceneSequenceExtensions_LocateBoundObjects_Params Parms{}; Parms.Sequence = Sequence; Parms.InBinding = InBinding; Parms.Context = Context; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneSequenceExtensions.IsReadOnly // (Final, Native, Static, Public, BlueprintCallable) // Parameters: // class UMovieSceneSequence* Sequence (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) bool UMovieSceneSequenceExtensions::IsReadOnly(class UMovieSceneSequence* Sequence) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneSequenceExtensions", "IsReadOnly"); Params::UMovieSceneSequenceExtensions_IsReadOnly_Params Parms{}; Parms.Sequence = Sequence; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneSequenceExtensions.GetWorkRangeStart // (Final, Native, Static, Public, BlueprintCallable, BlueprintPure) // Parameters: // class UMovieSceneSequence* InSequence (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) float UMovieSceneSequenceExtensions::GetWorkRangeStart(class UMovieSceneSequence* InSequence) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneSequenceExtensions", "GetWorkRangeStart"); Params::UMovieSceneSequenceExtensions_GetWorkRangeStart_Params Parms{}; Parms.InSequence = InSequence; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneSequenceExtensions.GetWorkRangeEnd // (Final, Native, Static, Public, BlueprintCallable, BlueprintPure) // Parameters: // class UMovieSceneSequence* InSequence (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) float UMovieSceneSequenceExtensions::GetWorkRangeEnd(class UMovieSceneSequence* InSequence) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneSequenceExtensions", "GetWorkRangeEnd"); Params::UMovieSceneSequenceExtensions_GetWorkRangeEnd_Params Parms{}; Parms.InSequence = InSequence; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneSequenceExtensions.GetViewRangeStart // (Final, Native, Static, Public, BlueprintCallable, BlueprintPure) // Parameters: // class UMovieSceneSequence* InSequence (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) float UMovieSceneSequenceExtensions::GetViewRangeStart(class UMovieSceneSequence* InSequence) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneSequenceExtensions", "GetViewRangeStart"); Params::UMovieSceneSequenceExtensions_GetViewRangeStart_Params Parms{}; Parms.InSequence = InSequence; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneSequenceExtensions.GetViewRangeEnd // (Final, Native, Static, Public, BlueprintCallable, BlueprintPure) // Parameters: // class UMovieSceneSequence* InSequence (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) float UMovieSceneSequenceExtensions::GetViewRangeEnd(class UMovieSceneSequence* InSequence) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneSequenceExtensions", "GetViewRangeEnd"); Params::UMovieSceneSequenceExtensions_GetViewRangeEnd_Params Parms{}; Parms.InSequence = InSequence; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneSequenceExtensions.GetTimecodeSource // (Final, Native, Static, Public, BlueprintCallable) // Parameters: // class UMovieSceneSequence* Sequence (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // struct FTimecode ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) struct FTimecode UMovieSceneSequenceExtensions::GetTimecodeSource(class UMovieSceneSequence* Sequence) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneSequenceExtensions", "GetTimecodeSource"); Params::UMovieSceneSequenceExtensions_GetTimecodeSource_Params Parms{}; Parms.Sequence = Sequence; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneSequenceExtensions.GetTickResolution // (Final, Native, Static, Public, BlueprintCallable) // Parameters: // class UMovieSceneSequence* Sequence (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // struct FFrameRate ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) struct FFrameRate UMovieSceneSequenceExtensions::GetTickResolution(class UMovieSceneSequence* Sequence) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneSequenceExtensions", "GetTickResolution"); Params::UMovieSceneSequenceExtensions_GetTickResolution_Params Parms{}; Parms.Sequence = Sequence; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneSequenceExtensions.GetSpawnables // (Final, Native, Static, Public, BlueprintCallable) // Parameters: // class UMovieSceneSequence* Sequence (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // TArrayReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic) TArray UMovieSceneSequenceExtensions::GetSpawnables(class UMovieSceneSequence* Sequence) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneSequenceExtensions", "GetSpawnables"); Params::UMovieSceneSequenceExtensions_GetSpawnables_Params Parms{}; Parms.Sequence = Sequence; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneSequenceExtensions.GetRootFoldersInSequence // (Final, Native, Static, Public, BlueprintCallable, BlueprintPure) // Parameters: // class UMovieSceneSequence* Sequence (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // TArray ReturnValue (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, ContainsInstancedReference, NativeAccessSpecifierPublic) TArray UMovieSceneSequenceExtensions::GetRootFoldersInSequence(class UMovieSceneSequence* Sequence) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneSequenceExtensions", "GetRootFoldersInSequence"); Params::UMovieSceneSequenceExtensions_GetRootFoldersInSequence_Params Parms{}; Parms.Sequence = Sequence; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneSequenceExtensions.GetPossessables // (Final, Native, Static, Public, BlueprintCallable) // Parameters: // class UMovieSceneSequence* Sequence (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // TArrayReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic) TArray UMovieSceneSequenceExtensions::GetPossessables(class UMovieSceneSequence* Sequence) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneSequenceExtensions", "GetPossessables"); Params::UMovieSceneSequenceExtensions_GetPossessables_Params Parms{}; Parms.Sequence = Sequence; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneSequenceExtensions.GetPortableBindingID // (Final, Native, Static, Public, HasOutParams, BlueprintCallable) // Parameters: // class UMovieSceneSequence* MasterSequence (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // class UMovieSceneSequence* DestinationSequence (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // struct FMovieSceneBindingProxy InBinding (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic) // struct FMovieSceneObjectBindingID ReturnValue (Parm, OutParm, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) struct FMovieSceneObjectBindingID UMovieSceneSequenceExtensions::GetPortableBindingID(class UMovieSceneSequence* MasterSequence, class UMovieSceneSequence* DestinationSequence, struct FMovieSceneBindingProxy& InBinding) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneSequenceExtensions", "GetPortableBindingID"); Params::UMovieSceneSequenceExtensions_GetPortableBindingID_Params Parms{}; Parms.MasterSequence = MasterSequence; Parms.DestinationSequence = DestinationSequence; Parms.InBinding = InBinding; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneSequenceExtensions.GetPlaybackStartSeconds // (Final, Native, Static, Public, BlueprintCallable) // Parameters: // class UMovieSceneSequence* Sequence (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) float UMovieSceneSequenceExtensions::GetPlaybackStartSeconds(class UMovieSceneSequence* Sequence) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneSequenceExtensions", "GetPlaybackStartSeconds"); Params::UMovieSceneSequenceExtensions_GetPlaybackStartSeconds_Params Parms{}; Parms.Sequence = Sequence; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneSequenceExtensions.GetPlaybackStart // (Final, Native, Static, Public, BlueprintCallable) // Parameters: // class UMovieSceneSequence* Sequence (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // int32 ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) int32 UMovieSceneSequenceExtensions::GetPlaybackStart(class UMovieSceneSequence* Sequence) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneSequenceExtensions", "GetPlaybackStart"); Params::UMovieSceneSequenceExtensions_GetPlaybackStart_Params Parms{}; Parms.Sequence = Sequence; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneSequenceExtensions.GetPlaybackRange // (Final, Native, Static, Public, BlueprintCallable) // Parameters: // class UMovieSceneSequence* Sequence (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // struct FSequencerScriptingRange ReturnValue (Parm, OutParm, ReturnParm, NoDestructor, NativeAccessSpecifierPublic) struct FSequencerScriptingRange UMovieSceneSequenceExtensions::GetPlaybackRange(class UMovieSceneSequence* Sequence) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneSequenceExtensions", "GetPlaybackRange"); Params::UMovieSceneSequenceExtensions_GetPlaybackRange_Params Parms{}; Parms.Sequence = Sequence; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneSequenceExtensions.GetPlaybackEndSeconds // (Final, Native, Static, Public, BlueprintCallable) // Parameters: // class UMovieSceneSequence* Sequence (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) float UMovieSceneSequenceExtensions::GetPlaybackEndSeconds(class UMovieSceneSequence* Sequence) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneSequenceExtensions", "GetPlaybackEndSeconds"); Params::UMovieSceneSequenceExtensions_GetPlaybackEndSeconds_Params Parms{}; Parms.Sequence = Sequence; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneSequenceExtensions.GetPlaybackEnd // (Final, Native, Static, Public, BlueprintCallable) // Parameters: // class UMovieSceneSequence* Sequence (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // int32 ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) int32 UMovieSceneSequenceExtensions::GetPlaybackEnd(class UMovieSceneSequence* Sequence) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneSequenceExtensions", "GetPlaybackEnd"); Params::UMovieSceneSequenceExtensions_GetPlaybackEnd_Params Parms{}; Parms.Sequence = Sequence; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneSequenceExtensions.GetMovieScene // (Final, Native, Static, Public, BlueprintCallable) // Parameters: // class UMovieSceneSequence* Sequence (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // class UMovieScene* ReturnValue (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) class UMovieScene* UMovieSceneSequenceExtensions::GetMovieScene(class UMovieSceneSequence* Sequence) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneSequenceExtensions", "GetMovieScene"); Params::UMovieSceneSequenceExtensions_GetMovieScene_Params Parms{}; Parms.Sequence = Sequence; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneSequenceExtensions.GetMasterTracks // (Final, Native, Static, Public, BlueprintCallable) // Parameters: // class UMovieSceneSequence* Sequence (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // TArray ReturnValue (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, ContainsInstancedReference, NativeAccessSpecifierPublic) TArray UMovieSceneSequenceExtensions::GetMasterTracks(class UMovieSceneSequence* Sequence) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneSequenceExtensions", "GetMasterTracks"); Params::UMovieSceneSequenceExtensions_GetMasterTracks_Params Parms{}; Parms.Sequence = Sequence; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneSequenceExtensions.GetMarkedFrames // (Final, Native, Static, Public, BlueprintCallable) // Parameters: // class UMovieSceneSequence* Sequence (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // TArrayReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic) TArray UMovieSceneSequenceExtensions::GetMarkedFrames(class UMovieSceneSequence* Sequence) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneSequenceExtensions", "GetMarkedFrames"); Params::UMovieSceneSequenceExtensions_GetMarkedFrames_Params Parms{}; Parms.Sequence = Sequence; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneSequenceExtensions.GetEvaluationType // (Final, Native, Static, Public, BlueprintCallable, BlueprintPure) // Parameters: // class UMovieSceneSequence* InSequence (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // enum class EMovieSceneEvaluationTypeReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) enum class EMovieSceneEvaluationType UMovieSceneSequenceExtensions::GetEvaluationType(class UMovieSceneSequence* InSequence) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneSequenceExtensions", "GetEvaluationType"); Params::UMovieSceneSequenceExtensions_GetEvaluationType_Params Parms{}; Parms.InSequence = InSequence; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneSequenceExtensions.GetDisplayRate // (Final, Native, Static, Public, BlueprintCallable) // Parameters: // class UMovieSceneSequence* Sequence (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // struct FFrameRate ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) struct FFrameRate UMovieSceneSequenceExtensions::GetDisplayRate(class UMovieSceneSequence* Sequence) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneSequenceExtensions", "GetDisplayRate"); Params::UMovieSceneSequenceExtensions_GetDisplayRate_Params Parms{}; Parms.Sequence = Sequence; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneSequenceExtensions.GetClockSource // (Final, Native, Static, Public, BlueprintCallable, BlueprintPure) // Parameters: // class UMovieSceneSequence* InSequence (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // enum class EUpdateClockSource ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) enum class EUpdateClockSource UMovieSceneSequenceExtensions::GetClockSource(class UMovieSceneSequence* InSequence) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneSequenceExtensions", "GetClockSource"); Params::UMovieSceneSequenceExtensions_GetClockSource_Params Parms{}; Parms.InSequence = InSequence; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneSequenceExtensions.GetBindings // (Final, Native, Static, Public, BlueprintCallable) // Parameters: // class UMovieSceneSequence* Sequence (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // TArrayReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic) TArray UMovieSceneSequenceExtensions::GetBindings(class UMovieSceneSequence* Sequence) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneSequenceExtensions", "GetBindings"); Params::UMovieSceneSequenceExtensions_GetBindings_Params Parms{}; Parms.Sequence = Sequence; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneSequenceExtensions.GetBindingID // (Final, Native, Static, Public, HasOutParams, BlueprintCallable) // Parameters: // struct FMovieSceneBindingProxy InBinding (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic) // struct FMovieSceneObjectBindingID ReturnValue (Parm, OutParm, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) struct FMovieSceneObjectBindingID UMovieSceneSequenceExtensions::GetBindingID(struct FMovieSceneBindingProxy& InBinding) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneSequenceExtensions", "GetBindingID"); Params::UMovieSceneSequenceExtensions_GetBindingID_Params Parms{}; Parms.InBinding = InBinding; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneSequenceExtensions.FindNextMarkedFrame // (Final, Native, Static, Public, HasDefaults, BlueprintCallable) // Parameters: // class UMovieSceneSequence* Sequence (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // struct FFrameNumber InFrameNumber (Parm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // bool bForward (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // int32 ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) int32 UMovieSceneSequenceExtensions::FindNextMarkedFrame(class UMovieSceneSequence* Sequence, const struct FFrameNumber& InFrameNumber, bool bForward) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneSequenceExtensions", "FindNextMarkedFrame"); Params::UMovieSceneSequenceExtensions_FindNextMarkedFrame_Params Parms{}; Parms.Sequence = Sequence; Parms.InFrameNumber = InFrameNumber; Parms.bForward = bForward; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneSequenceExtensions.FindMasterTracksByType // (Final, Native, Static, Public, BlueprintCallable) // Parameters: // class UMovieSceneSequence* Sequence (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // TSubclassOfTrackType (Parm, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic) // TArray ReturnValue (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, ContainsInstancedReference, NativeAccessSpecifierPublic) TArray UMovieSceneSequenceExtensions::FindMasterTracksByType(class UMovieSceneSequence* Sequence, TSubclassOf TrackType) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneSequenceExtensions", "FindMasterTracksByType"); Params::UMovieSceneSequenceExtensions_FindMasterTracksByType_Params Parms{}; Parms.Sequence = Sequence; Parms.TrackType = TrackType; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneSequenceExtensions.FindMasterTracksByExactType // (Final, Native, Static, Public, BlueprintCallable) // Parameters: // class UMovieSceneSequence* Sequence (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // TSubclassOfTrackType (Parm, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic) // TArray ReturnValue (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, ContainsInstancedReference, NativeAccessSpecifierPublic) TArray UMovieSceneSequenceExtensions::FindMasterTracksByExactType(class UMovieSceneSequence* Sequence, TSubclassOf TrackType) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneSequenceExtensions", "FindMasterTracksByExactType"); Params::UMovieSceneSequenceExtensions_FindMasterTracksByExactType_Params Parms{}; Parms.Sequence = Sequence; Parms.TrackType = TrackType; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneSequenceExtensions.FindMarkedFrameByLabel // (Final, Native, Static, Public, BlueprintCallable) // Parameters: // class UMovieSceneSequence* Sequence (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // class FString InLabel (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // int32 ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) int32 UMovieSceneSequenceExtensions::FindMarkedFrameByLabel(class UMovieSceneSequence* Sequence, const class FString& InLabel) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneSequenceExtensions", "FindMarkedFrameByLabel"); Params::UMovieSceneSequenceExtensions_FindMarkedFrameByLabel_Params Parms{}; Parms.Sequence = Sequence; Parms.InLabel = InLabel; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneSequenceExtensions.FindMarkedFrameByFrameNumber // (Final, Native, Static, Public, HasDefaults, BlueprintCallable) // Parameters: // class UMovieSceneSequence* Sequence (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // struct FFrameNumber InFrameNumber (Parm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // int32 ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) int32 UMovieSceneSequenceExtensions::FindMarkedFrameByFrameNumber(class UMovieSceneSequence* Sequence, const struct FFrameNumber& InFrameNumber) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneSequenceExtensions", "FindMarkedFrameByFrameNumber"); Params::UMovieSceneSequenceExtensions_FindMarkedFrameByFrameNumber_Params Parms{}; Parms.Sequence = Sequence; Parms.InFrameNumber = InFrameNumber; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneSequenceExtensions.FindBindingByName // (Final, Native, Static, Public, BlueprintCallable) // Parameters: // class UMovieSceneSequence* Sequence (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // class FString Name (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // struct FMovieSceneBindingProxy ReturnValue (Parm, OutParm, ReturnParm, NoDestructor, NativeAccessSpecifierPublic) struct FMovieSceneBindingProxy UMovieSceneSequenceExtensions::FindBindingByName(class UMovieSceneSequence* Sequence, const class FString& Name) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneSequenceExtensions", "FindBindingByName"); Params::UMovieSceneSequenceExtensions_FindBindingByName_Params Parms{}; Parms.Sequence = Sequence; Parms.Name = Name; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneSequenceExtensions.FindBindingById // (Final, Native, Static, Public, HasDefaults, BlueprintCallable) // Parameters: // class UMovieSceneSequence* Sequence (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // struct FGuid BindingId (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // struct FMovieSceneBindingProxy ReturnValue (Parm, OutParm, ReturnParm, NoDestructor, NativeAccessSpecifierPublic) struct FMovieSceneBindingProxy UMovieSceneSequenceExtensions::FindBindingById(class UMovieSceneSequence* Sequence, const struct FGuid& BindingId) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneSequenceExtensions", "FindBindingById"); Params::UMovieSceneSequenceExtensions_FindBindingById_Params Parms{}; Parms.Sequence = Sequence; Parms.BindingId = BindingId; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneSequenceExtensions.DeleteMarkedFrames // (Final, Native, Static, Public, BlueprintCallable) // Parameters: // class UMovieSceneSequence* Sequence (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) void UMovieSceneSequenceExtensions::DeleteMarkedFrames(class UMovieSceneSequence* Sequence) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneSequenceExtensions", "DeleteMarkedFrames"); Params::UMovieSceneSequenceExtensions_DeleteMarkedFrames_Params Parms{}; Parms.Sequence = Sequence; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; } // Function SequencerScripting.MovieSceneSequenceExtensions.DeleteMarkedFrame // (Final, Native, Static, Public, BlueprintCallable) // Parameters: // class UMovieSceneSequence* Sequence (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // int32 DeleteIndex (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) void UMovieSceneSequenceExtensions::DeleteMarkedFrame(class UMovieSceneSequence* Sequence, int32 DeleteIndex) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneSequenceExtensions", "DeleteMarkedFrame"); Params::UMovieSceneSequenceExtensions_DeleteMarkedFrame_Params Parms{}; Parms.Sequence = Sequence; Parms.DeleteIndex = DeleteIndex; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; } // Function SequencerScripting.MovieSceneSequenceExtensions.AddSpawnableFromInstance // (Final, Native, Static, Public, BlueprintCallable) // Parameters: // class UMovieSceneSequence* Sequence (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // class UObject* ObjectToSpawn (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // struct FMovieSceneBindingProxy ReturnValue (Parm, OutParm, ReturnParm, NoDestructor, NativeAccessSpecifierPublic) struct FMovieSceneBindingProxy UMovieSceneSequenceExtensions::AddSpawnableFromInstance(class UMovieSceneSequence* Sequence, class UObject* ObjectToSpawn) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneSequenceExtensions", "AddSpawnableFromInstance"); Params::UMovieSceneSequenceExtensions_AddSpawnableFromInstance_Params Parms{}; Parms.Sequence = Sequence; Parms.ObjectToSpawn = ObjectToSpawn; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneSequenceExtensions.AddSpawnableFromClass // (Final, Native, Static, Public, BlueprintCallable) // Parameters: // class UMovieSceneSequence* Sequence (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // class UClass* ClassToSpawn (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // struct FMovieSceneBindingProxy ReturnValue (Parm, OutParm, ReturnParm, NoDestructor, NativeAccessSpecifierPublic) struct FMovieSceneBindingProxy UMovieSceneSequenceExtensions::AddSpawnableFromClass(class UMovieSceneSequence* Sequence, class UClass* ClassToSpawn) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneSequenceExtensions", "AddSpawnableFromClass"); Params::UMovieSceneSequenceExtensions_AddSpawnableFromClass_Params Parms{}; Parms.Sequence = Sequence; Parms.ClassToSpawn = ClassToSpawn; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneSequenceExtensions.AddRootFolderToSequence // (Final, Native, Static, Public, BlueprintCallable) // Parameters: // class UMovieSceneSequence* Sequence (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // class FString NewFolderName (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // class UMovieSceneFolder* ReturnValue (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) class UMovieSceneFolder* UMovieSceneSequenceExtensions::AddRootFolderToSequence(class UMovieSceneSequence* Sequence, const class FString& NewFolderName) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneSequenceExtensions", "AddRootFolderToSequence"); Params::UMovieSceneSequenceExtensions_AddRootFolderToSequence_Params Parms{}; Parms.Sequence = Sequence; Parms.NewFolderName = NewFolderName; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneSequenceExtensions.AddPossessable // (Final, Native, Static, Public, BlueprintCallable) // Parameters: // class UMovieSceneSequence* Sequence (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // class UObject* ObjectToPossess (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // struct FMovieSceneBindingProxy ReturnValue (Parm, OutParm, ReturnParm, NoDestructor, NativeAccessSpecifierPublic) struct FMovieSceneBindingProxy UMovieSceneSequenceExtensions::AddPossessable(class UMovieSceneSequence* Sequence, class UObject* ObjectToPossess) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneSequenceExtensions", "AddPossessable"); Params::UMovieSceneSequenceExtensions_AddPossessable_Params Parms{}; Parms.Sequence = Sequence; Parms.ObjectToPossess = ObjectToPossess; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneSequenceExtensions.AddMasterTrack // (Final, Native, Static, Public, BlueprintCallable) // Parameters: // class UMovieSceneSequence* Sequence (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // TSubclassOfTrackType (Parm, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic) // class UMovieSceneTrack* ReturnValue (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) class UMovieSceneTrack* UMovieSceneSequenceExtensions::AddMasterTrack(class UMovieSceneSequence* Sequence, TSubclassOf TrackType) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneSequenceExtensions", "AddMasterTrack"); Params::UMovieSceneSequenceExtensions_AddMasterTrack_Params Parms{}; Parms.Sequence = Sequence; Parms.TrackType = TrackType; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneSequenceExtensions.AddMarkedFrame // (Final, Native, Static, Public, HasOutParams, BlueprintCallable) // Parameters: // class UMovieSceneSequence* Sequence (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // struct FMovieSceneMarkedFrame InMarkedFrame (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic) // int32 ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) int32 UMovieSceneSequenceExtensions::AddMarkedFrame(class UMovieSceneSequence* Sequence, struct FMovieSceneMarkedFrame& InMarkedFrame) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneSequenceExtensions", "AddMarkedFrame"); Params::UMovieSceneSequenceExtensions_AddMarkedFrame_Params Parms{}; Parms.Sequence = Sequence; Parms.InMarkedFrame = InMarkedFrame; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Class SequencerScripting.MovieSceneTrackExtensions // (None) class UClass* UMovieSceneTrackExtensions::StaticClass() { static class UClass* Clss = nullptr; if (!Clss) Clss = UObject::FindClassFast("MovieSceneTrackExtensions"); return Clss; } // MovieSceneTrackExtensions SequencerScripting.Default__MovieSceneTrackExtensions // (Public, ClassDefaultObject, ArchetypeObject) class UMovieSceneTrackExtensions* UMovieSceneTrackExtensions::GetDefaultObj() { static class UMovieSceneTrackExtensions* Default = nullptr; if (!Default) Default = static_cast(UMovieSceneTrackExtensions::StaticClass()->DefaultObject); return Default; } // Function SequencerScripting.MovieSceneTrackExtensions.SetTrackRowDisplayName // (Final, Native, Static, Public, HasOutParams, BlueprintCallable) // Parameters: // class UMovieSceneTrack* Track (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // class FText InName (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic) // int32 RowIndex (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) void UMovieSceneTrackExtensions::SetTrackRowDisplayName(class UMovieSceneTrack* Track, class FText& InName, int32 RowIndex) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneTrackExtensions", "SetTrackRowDisplayName"); Params::UMovieSceneTrackExtensions_SetTrackRowDisplayName_Params Parms{}; Parms.Track = Track; Parms.InName = InName; Parms.RowIndex = RowIndex; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; } // Function SequencerScripting.MovieSceneTrackExtensions.SetSortingOrder // (Final, Native, Static, Public, BlueprintCallable) // Parameters: // class UMovieSceneTrack* Track (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // int32 SortingOrder (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) void UMovieSceneTrackExtensions::SetSortingOrder(class UMovieSceneTrack* Track, int32 SortingOrder) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneTrackExtensions", "SetSortingOrder"); Params::UMovieSceneTrackExtensions_SetSortingOrder_Params Parms{}; Parms.Track = Track; Parms.SortingOrder = SortingOrder; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; } // Function SequencerScripting.MovieSceneTrackExtensions.SetSectionToKey // (Final, Native, Static, Public, BlueprintCallable) // Parameters: // class UMovieSceneTrack* Track (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // class UMovieSceneSection* Section (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) void UMovieSceneTrackExtensions::SetSectionToKey(class UMovieSceneTrack* Track, class UMovieSceneSection* Section) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneTrackExtensions", "SetSectionToKey"); Params::UMovieSceneTrackExtensions_SetSectionToKey_Params Parms{}; Parms.Track = Track; Parms.Section = Section; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; } // Function SequencerScripting.MovieSceneTrackExtensions.SetDisplayName // (Final, Native, Static, Public, HasOutParams, BlueprintCallable) // Parameters: // class UMovieSceneTrack* Track (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // class FText InName (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic) void UMovieSceneTrackExtensions::SetDisplayName(class UMovieSceneTrack* Track, class FText& InName) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneTrackExtensions", "SetDisplayName"); Params::UMovieSceneTrackExtensions_SetDisplayName_Params Parms{}; Parms.Track = Track; Parms.InName = InName; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; } // Function SequencerScripting.MovieSceneTrackExtensions.SetColorTint // (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable) // Parameters: // class UMovieSceneTrack* Track (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // struct FColor ColorTint (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) void UMovieSceneTrackExtensions::SetColorTint(class UMovieSceneTrack* Track, struct FColor& ColorTint) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneTrackExtensions", "SetColorTint"); Params::UMovieSceneTrackExtensions_SetColorTint_Params Parms{}; Parms.Track = Track; Parms.ColorTint = ColorTint; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; } // Function SequencerScripting.MovieSceneTrackExtensions.RemoveSection // (Final, Native, Static, Public, BlueprintCallable) // Parameters: // class UMovieSceneTrack* Track (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // class UMovieSceneSection* Section (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) void UMovieSceneTrackExtensions::RemoveSection(class UMovieSceneTrack* Track, class UMovieSceneSection* Section) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneTrackExtensions", "RemoveSection"); Params::UMovieSceneTrackExtensions_RemoveSection_Params Parms{}; Parms.Track = Track; Parms.Section = Section; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; } // Function SequencerScripting.MovieSceneTrackExtensions.GetTrackRowDisplayName // (Final, Native, Static, Public, BlueprintCallable) // Parameters: // class UMovieSceneTrack* Track (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // int32 RowIndex (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // class FText ReturnValue (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic) class FText UMovieSceneTrackExtensions::GetTrackRowDisplayName(class UMovieSceneTrack* Track, int32 RowIndex) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneTrackExtensions", "GetTrackRowDisplayName"); Params::UMovieSceneTrackExtensions_GetTrackRowDisplayName_Params Parms{}; Parms.Track = Track; Parms.RowIndex = RowIndex; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneTrackExtensions.GetSortingOrder // (Final, Native, Static, Public, BlueprintCallable) // Parameters: // class UMovieSceneTrack* Track (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // int32 ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) int32 UMovieSceneTrackExtensions::GetSortingOrder(class UMovieSceneTrack* Track) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneTrackExtensions", "GetSortingOrder"); Params::UMovieSceneTrackExtensions_GetSortingOrder_Params Parms{}; Parms.Track = Track; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneTrackExtensions.GetSectionToKey // (Final, Native, Static, Public, BlueprintCallable) // Parameters: // class UMovieSceneTrack* Track (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // class UMovieSceneSection* ReturnValue (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) class UMovieSceneSection* UMovieSceneTrackExtensions::GetSectionToKey(class UMovieSceneTrack* Track) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneTrackExtensions", "GetSectionToKey"); Params::UMovieSceneTrackExtensions_GetSectionToKey_Params Parms{}; Parms.Track = Track; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneTrackExtensions.GetSections // (Final, Native, Static, Public, BlueprintCallable) // Parameters: // class UMovieSceneTrack* Track (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // TArray ReturnValue (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, ContainsInstancedReference, NativeAccessSpecifierPublic) TArray UMovieSceneTrackExtensions::GetSections(class UMovieSceneTrack* Track) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneTrackExtensions", "GetSections"); Params::UMovieSceneTrackExtensions_GetSections_Params Parms{}; Parms.Track = Track; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneTrackExtensions.GetDisplayName // (Final, Native, Static, Public, BlueprintCallable) // Parameters: // class UMovieSceneTrack* Track (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // class FText ReturnValue (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic) class FText UMovieSceneTrackExtensions::GetDisplayName(class UMovieSceneTrack* Track) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneTrackExtensions", "GetDisplayName"); Params::UMovieSceneTrackExtensions_GetDisplayName_Params Parms{}; Parms.Track = Track; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneTrackExtensions.GetColorTint // (Final, Native, Static, Public, HasDefaults, BlueprintCallable) // Parameters: // class UMovieSceneTrack* Track (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // struct FColor ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) struct FColor UMovieSceneTrackExtensions::GetColorTint(class UMovieSceneTrack* Track) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneTrackExtensions", "GetColorTint"); Params::UMovieSceneTrackExtensions_GetColorTint_Params Parms{}; Parms.Track = Track; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.MovieSceneTrackExtensions.AddSection // (Final, Native, Static, Public, BlueprintCallable) // Parameters: // class UMovieSceneTrack* Track (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // class UMovieSceneSection* ReturnValue (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) class UMovieSceneSection* UMovieSceneTrackExtensions::AddSection(class UMovieSceneTrack* Track) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneTrackExtensions", "AddSection"); Params::UMovieSceneTrackExtensions_AddSection_Params Parms{}; Parms.Track = Track; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Class SequencerScripting.MovieSceneFloatVectorTrackExtensions // (None) class UClass* UMovieSceneFloatVectorTrackExtensions::StaticClass() { static class UClass* Clss = nullptr; if (!Clss) Clss = UObject::FindClassFast("MovieSceneFloatVectorTrackExtensions"); return Clss; } // MovieSceneFloatVectorTrackExtensions SequencerScripting.Default__MovieSceneFloatVectorTrackExtensions // (Public, ClassDefaultObject, ArchetypeObject) class UMovieSceneFloatVectorTrackExtensions* UMovieSceneFloatVectorTrackExtensions::GetDefaultObj() { static class UMovieSceneFloatVectorTrackExtensions* Default = nullptr; if (!Default) Default = static_cast(UMovieSceneFloatVectorTrackExtensions::StaticClass()->DefaultObject); return Default; } // Function SequencerScripting.MovieSceneFloatVectorTrackExtensions.SetNumChannelsUsed // (Final, Native, Static, Public, BlueprintCallable) // Parameters: // class UMovieSceneFloatVectorTrack* Track (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // int32 InNumChannelsUsed (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) void UMovieSceneFloatVectorTrackExtensions::SetNumChannelsUsed(class UMovieSceneFloatVectorTrack* Track, int32 InNumChannelsUsed) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneFloatVectorTrackExtensions", "SetNumChannelsUsed"); Params::UMovieSceneFloatVectorTrackExtensions_SetNumChannelsUsed_Params Parms{}; Parms.Track = Track; Parms.InNumChannelsUsed = InNumChannelsUsed; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; } // Function SequencerScripting.MovieSceneFloatVectorTrackExtensions.GetNumChannelsUsed // (Final, Native, Static, Public, BlueprintCallable) // Parameters: // class UMovieSceneFloatVectorTrack* Track (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // int32 ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) int32 UMovieSceneFloatVectorTrackExtensions::GetNumChannelsUsed(class UMovieSceneFloatVectorTrack* Track) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneFloatVectorTrackExtensions", "GetNumChannelsUsed"); Params::UMovieSceneFloatVectorTrackExtensions_GetNumChannelsUsed_Params Parms{}; Parms.Track = Track; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Class SequencerScripting.MovieSceneDoubleVectorTrackExtensions // (None) class UClass* UMovieSceneDoubleVectorTrackExtensions::StaticClass() { static class UClass* Clss = nullptr; if (!Clss) Clss = UObject::FindClassFast("MovieSceneDoubleVectorTrackExtensions"); return Clss; } // MovieSceneDoubleVectorTrackExtensions SequencerScripting.Default__MovieSceneDoubleVectorTrackExtensions // (Public, ClassDefaultObject, ArchetypeObject) class UMovieSceneDoubleVectorTrackExtensions* UMovieSceneDoubleVectorTrackExtensions::GetDefaultObj() { static class UMovieSceneDoubleVectorTrackExtensions* Default = nullptr; if (!Default) Default = static_cast(UMovieSceneDoubleVectorTrackExtensions::StaticClass()->DefaultObject); return Default; } // Function SequencerScripting.MovieSceneDoubleVectorTrackExtensions.SetNumChannelsUsed // (Final, Native, Static, Public, BlueprintCallable) // Parameters: // class UMovieSceneDoubleVectorTrack*Track (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // int32 InNumChannelsUsed (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) void UMovieSceneDoubleVectorTrackExtensions::SetNumChannelsUsed(class UMovieSceneDoubleVectorTrack* Track, int32 InNumChannelsUsed) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneDoubleVectorTrackExtensions", "SetNumChannelsUsed"); Params::UMovieSceneDoubleVectorTrackExtensions_SetNumChannelsUsed_Params Parms{}; Parms.Track = Track; Parms.InNumChannelsUsed = InNumChannelsUsed; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; } // Function SequencerScripting.MovieSceneDoubleVectorTrackExtensions.GetNumChannelsUsed // (Final, Native, Static, Public, BlueprintCallable) // Parameters: // class UMovieSceneDoubleVectorTrack*Track (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // int32 ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) int32 UMovieSceneDoubleVectorTrackExtensions::GetNumChannelsUsed(class UMovieSceneDoubleVectorTrack* Track) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("MovieSceneDoubleVectorTrackExtensions", "GetNumChannelsUsed"); Params::UMovieSceneDoubleVectorTrackExtensions_GetNumChannelsUsed_Params Parms{}; Parms.Track = Track; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Class SequencerScripting.SequencerScriptingRangeExtensions // (None) class UClass* USequencerScriptingRangeExtensions::StaticClass() { static class UClass* Clss = nullptr; if (!Clss) Clss = UObject::FindClassFast("SequencerScriptingRangeExtensions"); return Clss; } // SequencerScriptingRangeExtensions SequencerScripting.Default__SequencerScriptingRangeExtensions // (Public, ClassDefaultObject, ArchetypeObject) class USequencerScriptingRangeExtensions* USequencerScriptingRangeExtensions::GetDefaultObj() { static class USequencerScriptingRangeExtensions* Default = nullptr; if (!Default) Default = static_cast(USequencerScriptingRangeExtensions::StaticClass()->DefaultObject); return Default; } // Function SequencerScripting.SequencerScriptingRangeExtensions.SetStartSeconds // (Final, Native, Static, Public, HasOutParams, BlueprintCallable) // Parameters: // struct FSequencerScriptingRange Range (Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic) // float Start (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) void USequencerScriptingRangeExtensions::SetStartSeconds(struct FSequencerScriptingRange& Range, float Start) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("SequencerScriptingRangeExtensions", "SetStartSeconds"); Params::USequencerScriptingRangeExtensions_SetStartSeconds_Params Parms{}; Parms.Range = Range; Parms.Start = Start; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; } // Function SequencerScripting.SequencerScriptingRangeExtensions.SetStartFrame // (Final, Native, Static, Public, HasOutParams, BlueprintCallable) // Parameters: // struct FSequencerScriptingRange Range (Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic) // int32 Start (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) void USequencerScriptingRangeExtensions::SetStartFrame(struct FSequencerScriptingRange& Range, int32 Start) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("SequencerScriptingRangeExtensions", "SetStartFrame"); Params::USequencerScriptingRangeExtensions_SetStartFrame_Params Parms{}; Parms.Range = Range; Parms.Start = Start; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; } // Function SequencerScripting.SequencerScriptingRangeExtensions.SetEndSeconds // (Final, Native, Static, Public, HasOutParams, BlueprintCallable) // Parameters: // struct FSequencerScriptingRange Range (Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic) // float End (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) void USequencerScriptingRangeExtensions::SetEndSeconds(struct FSequencerScriptingRange& Range, float End) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("SequencerScriptingRangeExtensions", "SetEndSeconds"); Params::USequencerScriptingRangeExtensions_SetEndSeconds_Params Parms{}; Parms.Range = Range; Parms.End = End; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; } // Function SequencerScripting.SequencerScriptingRangeExtensions.SetEndFrame // (Final, Native, Static, Public, HasOutParams, BlueprintCallable) // Parameters: // struct FSequencerScriptingRange Range (Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic) // int32 End (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) void USequencerScriptingRangeExtensions::SetEndFrame(struct FSequencerScriptingRange& Range, int32 End) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("SequencerScriptingRangeExtensions", "SetEndFrame"); Params::USequencerScriptingRangeExtensions_SetEndFrame_Params Parms{}; Parms.Range = Range; Parms.End = End; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; } // Function SequencerScripting.SequencerScriptingRangeExtensions.RemoveStart // (Final, Native, Static, Public, HasOutParams, BlueprintCallable) // Parameters: // struct FSequencerScriptingRange Range (Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic) void USequencerScriptingRangeExtensions::RemoveStart(struct FSequencerScriptingRange& Range) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("SequencerScriptingRangeExtensions", "RemoveStart"); Params::USequencerScriptingRangeExtensions_RemoveStart_Params Parms{}; Parms.Range = Range; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; } // Function SequencerScripting.SequencerScriptingRangeExtensions.RemoveEnd // (Final, Native, Static, Public, HasOutParams, BlueprintCallable) // Parameters: // struct FSequencerScriptingRange Range (Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic) void USequencerScriptingRangeExtensions::RemoveEnd(struct FSequencerScriptingRange& Range) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("SequencerScriptingRangeExtensions", "RemoveEnd"); Params::USequencerScriptingRangeExtensions_RemoveEnd_Params Parms{}; Parms.Range = Range; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; } // Function SequencerScripting.SequencerScriptingRangeExtensions.HasStart // (Final, Native, Static, Public, HasOutParams, BlueprintCallable) // Parameters: // struct FSequencerScriptingRange Range (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic) // bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) bool USequencerScriptingRangeExtensions::HasStart(struct FSequencerScriptingRange& Range) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("SequencerScriptingRangeExtensions", "HasStart"); Params::USequencerScriptingRangeExtensions_HasStart_Params Parms{}; Parms.Range = Range; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.SequencerScriptingRangeExtensions.HasEnd // (Final, Native, Static, Public, HasOutParams, BlueprintCallable) // Parameters: // struct FSequencerScriptingRange Range (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic) // bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) bool USequencerScriptingRangeExtensions::HasEnd(struct FSequencerScriptingRange& Range) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("SequencerScriptingRangeExtensions", "HasEnd"); Params::USequencerScriptingRangeExtensions_HasEnd_Params Parms{}; Parms.Range = Range; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.SequencerScriptingRangeExtensions.GetStartSeconds // (Final, Native, Static, Public, HasOutParams, BlueprintCallable) // Parameters: // struct FSequencerScriptingRange Range (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic) // float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) float USequencerScriptingRangeExtensions::GetStartSeconds(struct FSequencerScriptingRange& Range) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("SequencerScriptingRangeExtensions", "GetStartSeconds"); Params::USequencerScriptingRangeExtensions_GetStartSeconds_Params Parms{}; Parms.Range = Range; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.SequencerScriptingRangeExtensions.GetStartFrame // (Final, Native, Static, Public, HasOutParams, BlueprintCallable) // Parameters: // struct FSequencerScriptingRange Range (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic) // int32 ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) int32 USequencerScriptingRangeExtensions::GetStartFrame(struct FSequencerScriptingRange& Range) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("SequencerScriptingRangeExtensions", "GetStartFrame"); Params::USequencerScriptingRangeExtensions_GetStartFrame_Params Parms{}; Parms.Range = Range; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.SequencerScriptingRangeExtensions.GetEndSeconds // (Final, Native, Static, Public, HasOutParams, BlueprintCallable) // Parameters: // struct FSequencerScriptingRange Range (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic) // float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) float USequencerScriptingRangeExtensions::GetEndSeconds(struct FSequencerScriptingRange& Range) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("SequencerScriptingRangeExtensions", "GetEndSeconds"); Params::USequencerScriptingRangeExtensions_GetEndSeconds_Params Parms{}; Parms.Range = Range; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function SequencerScripting.SequencerScriptingRangeExtensions.GetEndFrame // (Final, Native, Static, Public, HasOutParams, BlueprintCallable) // Parameters: // struct FSequencerScriptingRange Range (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic) // int32 ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) int32 USequencerScriptingRangeExtensions::GetEndFrame(struct FSequencerScriptingRange& Range) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("SequencerScriptingRangeExtensions", "GetEndFrame"); Params::USequencerScriptingRangeExtensions_GetEndFrame_Params Parms{}; Parms.Range = Range; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } }