#pragma once // Dumped with Dumper-7! #include "../SDK.hpp" namespace SDK { //--------------------------------------------------------------------------------------------------------------------- // FUNCTIONS //--------------------------------------------------------------------------------------------------------------------- // Class GeometryCache.GeometryCache // (None) class UClass* UGeometryCache::StaticClass() { static class UClass* Clss = nullptr; if (!Clss) Clss = UObject::FindClassFast("GeometryCache"); return Clss; } // GeometryCache GeometryCache.Default__GeometryCache // (Public, ClassDefaultObject, ArchetypeObject) class UGeometryCache* UGeometryCache::GetDefaultObj() { static class UGeometryCache* Default = nullptr; if (!Default) Default = static_cast(UGeometryCache::StaticClass()->DefaultObject); return Default; } // Class GeometryCache.GeometryCacheActor // (Actor) class UClass* AGeometryCacheActor::StaticClass() { static class UClass* Clss = nullptr; if (!Clss) Clss = UObject::FindClassFast("GeometryCacheActor"); return Clss; } // GeometryCacheActor GeometryCache.Default__GeometryCacheActor // (Public, ClassDefaultObject, ArchetypeObject) class AGeometryCacheActor* AGeometryCacheActor::GetDefaultObj() { static class AGeometryCacheActor* Default = nullptr; if (!Default) Default = static_cast(AGeometryCacheActor::StaticClass()->DefaultObject); return Default; } // Function GeometryCache.GeometryCacheActor.GetGeometryCacheComponent // (Final, Native, Public, BlueprintCallable, BlueprintPure, Const) // Parameters: // class UGeometryCacheComponent* ReturnValue (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) class UGeometryCacheComponent* AGeometryCacheActor::GetGeometryCacheComponent() { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("GeometryCacheActor", "GetGeometryCacheComponent"); Params::AGeometryCacheActor_GetGeometryCacheComponent_Params Parms{}; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Class GeometryCache.GeometryCacheCodecBase // (None) class UClass* UGeometryCacheCodecBase::StaticClass() { static class UClass* Clss = nullptr; if (!Clss) Clss = UObject::FindClassFast("GeometryCacheCodecBase"); return Clss; } // GeometryCacheCodecBase GeometryCache.Default__GeometryCacheCodecBase // (Public, ClassDefaultObject, ArchetypeObject) class UGeometryCacheCodecBase* UGeometryCacheCodecBase::GetDefaultObj() { static class UGeometryCacheCodecBase* Default = nullptr; if (!Default) Default = static_cast(UGeometryCacheCodecBase::StaticClass()->DefaultObject); return Default; } // Class GeometryCache.GeometryCacheCodecRaw // (None) class UClass* UGeometryCacheCodecRaw::StaticClass() { static class UClass* Clss = nullptr; if (!Clss) Clss = UObject::FindClassFast("GeometryCacheCodecRaw"); return Clss; } // GeometryCacheCodecRaw GeometryCache.Default__GeometryCacheCodecRaw // (Public, ClassDefaultObject, ArchetypeObject) class UGeometryCacheCodecRaw* UGeometryCacheCodecRaw::GetDefaultObj() { static class UGeometryCacheCodecRaw* Default = nullptr; if (!Default) Default = static_cast(UGeometryCacheCodecRaw::StaticClass()->DefaultObject); return Default; } // Class GeometryCache.GeometryCacheCodecV1 // (None) class UClass* UGeometryCacheCodecV1::StaticClass() { static class UClass* Clss = nullptr; if (!Clss) Clss = UObject::FindClassFast("GeometryCacheCodecV1"); return Clss; } // GeometryCacheCodecV1 GeometryCache.Default__GeometryCacheCodecV1 // (Public, ClassDefaultObject, ArchetypeObject) class UGeometryCacheCodecV1* UGeometryCacheCodecV1::GetDefaultObj() { static class UGeometryCacheCodecV1* Default = nullptr; if (!Default) Default = static_cast(UGeometryCacheCodecV1::StaticClass()->DefaultObject); return Default; } // Class GeometryCache.GeometryCacheComponent // (SceneComponent, PrimitiveComponent) class UClass* UGeometryCacheComponent::StaticClass() { static class UClass* Clss = nullptr; if (!Clss) Clss = UObject::FindClassFast("GeometryCacheComponent"); return Clss; } // GeometryCacheComponent GeometryCache.Default__GeometryCacheComponent // (Public, ClassDefaultObject, ArchetypeObject) class UGeometryCacheComponent* UGeometryCacheComponent::GetDefaultObj() { static class UGeometryCacheComponent* Default = nullptr; if (!Default) Default = static_cast(UGeometryCacheComponent::StaticClass()->DefaultObject); return Default; } // Function GeometryCache.GeometryCacheComponent.TickAtThisTime // (Final, Native, Public, BlueprintCallable) // Parameters: // float Time (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // bool bInIsRunning (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // bool bInBackwards (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // bool bInIsLooping (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) void UGeometryCacheComponent::TickAtThisTime(float Time, bool bInIsRunning, bool bInBackwards, bool bInIsLooping) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("GeometryCacheComponent", "TickAtThisTime"); Params::UGeometryCacheComponent_TickAtThisTime_Params Parms{}; Parms.Time = Time; Parms.bInIsRunning = bInIsRunning; Parms.bInBackwards = bInBackwards; Parms.bInIsLooping = bInIsLooping; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; } // Function GeometryCache.GeometryCacheComponent.Stop // (Final, Native, Public, BlueprintCallable) // Parameters: void UGeometryCacheComponent::Stop() { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("GeometryCacheComponent", "Stop"); auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, nullptr); Func->FunctionFlags = Flgs; } // Function GeometryCache.GeometryCacheComponent.SetWireframeOverrideColor // (Final, Native, Public, HasDefaults, BlueprintCallable) // Parameters: // struct FLinearColor Color (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) void UGeometryCacheComponent::SetWireframeOverrideColor(const struct FLinearColor& Color) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("GeometryCacheComponent", "SetWireframeOverrideColor"); Params::UGeometryCacheComponent_SetWireframeOverrideColor_Params Parms{}; Parms.Color = Color; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; } // Function GeometryCache.GeometryCacheComponent.SetStartTimeOffset // (Final, Native, Public, BlueprintCallable) // Parameters: // float NewStartTimeOffset (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) void UGeometryCacheComponent::SetStartTimeOffset(float NewStartTimeOffset) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("GeometryCacheComponent", "SetStartTimeOffset"); Params::UGeometryCacheComponent_SetStartTimeOffset_Params Parms{}; Parms.NewStartTimeOffset = NewStartTimeOffset; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; } // Function GeometryCache.GeometryCacheComponent.SetPlaybackSpeed // (Final, Native, Public, BlueprintCallable) // Parameters: // float NewPlaybackSpeed (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) void UGeometryCacheComponent::SetPlaybackSpeed(float NewPlaybackSpeed) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("GeometryCacheComponent", "SetPlaybackSpeed"); Params::UGeometryCacheComponent_SetPlaybackSpeed_Params Parms{}; Parms.NewPlaybackSpeed = NewPlaybackSpeed; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; } // Function GeometryCache.GeometryCacheComponent.SetOverrideWireframeColor // (Final, Native, Public, BlueprintCallable) // Parameters: // bool bOverride (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) void UGeometryCacheComponent::SetOverrideWireframeColor(bool bOverride) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("GeometryCacheComponent", "SetOverrideWireframeColor"); Params::UGeometryCacheComponent_SetOverrideWireframeColor_Params Parms{}; Parms.bOverride = bOverride; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; } // Function GeometryCache.GeometryCacheComponent.SetMotionVectorScale // (Final, Native, Public, BlueprintCallable) // Parameters: // float NewMotionVectorScale (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) void UGeometryCacheComponent::SetMotionVectorScale(float NewMotionVectorScale) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("GeometryCacheComponent", "SetMotionVectorScale"); Params::UGeometryCacheComponent_SetMotionVectorScale_Params Parms{}; Parms.NewMotionVectorScale = NewMotionVectorScale; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; } // Function GeometryCache.GeometryCacheComponent.SetLooping // (Final, Native, Public, BlueprintCallable) // Parameters: // bool bNewLooping (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) void UGeometryCacheComponent::SetLooping(bool bNewLooping) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("GeometryCacheComponent", "SetLooping"); Params::UGeometryCacheComponent_SetLooping_Params Parms{}; Parms.bNewLooping = bNewLooping; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; } // Function GeometryCache.GeometryCacheComponent.SetGeometryCache // (Final, Native, Public, BlueprintCallable) // Parameters: // class UGeometryCache* NewGeomCache (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) // bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) bool UGeometryCacheComponent::SetGeometryCache(class UGeometryCache* NewGeomCache) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("GeometryCacheComponent", "SetGeometryCache"); Params::UGeometryCacheComponent_SetGeometryCache_Params Parms{}; Parms.NewGeomCache = NewGeomCache; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function GeometryCache.GeometryCacheComponent.SetExtrapolateFrames // (Final, Native, Public, BlueprintCallable) // Parameters: // bool bNewExtrapolating (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) void UGeometryCacheComponent::SetExtrapolateFrames(bool bNewExtrapolating) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("GeometryCacheComponent", "SetExtrapolateFrames"); Params::UGeometryCacheComponent_SetExtrapolateFrames_Params Parms{}; Parms.bNewExtrapolating = bNewExtrapolating; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; } // Function GeometryCache.GeometryCacheComponent.PlayReversedFromEnd // (Final, Native, Public, BlueprintCallable) // Parameters: void UGeometryCacheComponent::PlayReversedFromEnd() { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("GeometryCacheComponent", "PlayReversedFromEnd"); auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, nullptr); Func->FunctionFlags = Flgs; } // Function GeometryCache.GeometryCacheComponent.PlayReversed // (Final, Native, Public, BlueprintCallable) // Parameters: void UGeometryCacheComponent::PlayReversed() { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("GeometryCacheComponent", "PlayReversed"); auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, nullptr); Func->FunctionFlags = Flgs; } // Function GeometryCache.GeometryCacheComponent.PlayFromStart // (Final, Native, Public, BlueprintCallable) // Parameters: void UGeometryCacheComponent::PlayFromStart() { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("GeometryCacheComponent", "PlayFromStart"); auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, nullptr); Func->FunctionFlags = Flgs; } // Function GeometryCache.GeometryCacheComponent.Play // (Final, Native, Public, BlueprintCallable) // Parameters: void UGeometryCacheComponent::Play() { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("GeometryCacheComponent", "Play"); auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, nullptr); Func->FunctionFlags = Flgs; } // Function GeometryCache.GeometryCacheComponent.Pause // (Final, Native, Public, BlueprintCallable) // Parameters: void UGeometryCacheComponent::Pause() { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("GeometryCacheComponent", "Pause"); auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, nullptr); Func->FunctionFlags = Flgs; } // Function GeometryCache.GeometryCacheComponent.IsPlayingReversed // (Final, Native, Public, BlueprintCallable, BlueprintPure, Const) // Parameters: // bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) bool UGeometryCacheComponent::IsPlayingReversed() { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("GeometryCacheComponent", "IsPlayingReversed"); Params::UGeometryCacheComponent_IsPlayingReversed_Params Parms{}; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function GeometryCache.GeometryCacheComponent.IsPlaying // (Final, Native, Public, BlueprintCallable, BlueprintPure, Const) // Parameters: // bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) bool UGeometryCacheComponent::IsPlaying() { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("GeometryCacheComponent", "IsPlaying"); Params::UGeometryCacheComponent_IsPlaying_Params Parms{}; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function GeometryCache.GeometryCacheComponent.IsLooping // (Final, Native, Public, BlueprintCallable, BlueprintPure, Const) // Parameters: // bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) bool UGeometryCacheComponent::IsLooping() { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("GeometryCacheComponent", "IsLooping"); Params::UGeometryCacheComponent_IsLooping_Params Parms{}; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function GeometryCache.GeometryCacheComponent.IsExtrapolatingFrames // (Final, Native, Public, BlueprintCallable, BlueprintPure, Const) // Parameters: // bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) bool UGeometryCacheComponent::IsExtrapolatingFrames() { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("GeometryCacheComponent", "IsExtrapolatingFrames"); Params::UGeometryCacheComponent_IsExtrapolatingFrames_Params Parms{}; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function GeometryCache.GeometryCacheComponent.GetWireframeOverrideColor // (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const) // Parameters: // struct FLinearColor ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) struct FLinearColor UGeometryCacheComponent::GetWireframeOverrideColor() { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("GeometryCacheComponent", "GetWireframeOverrideColor"); Params::UGeometryCacheComponent_GetWireframeOverrideColor_Params Parms{}; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function GeometryCache.GeometryCacheComponent.GetStartTimeOffset // (Final, Native, Public, BlueprintCallable, BlueprintPure, Const) // Parameters: // float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) float UGeometryCacheComponent::GetStartTimeOffset() { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("GeometryCacheComponent", "GetStartTimeOffset"); Params::UGeometryCacheComponent_GetStartTimeOffset_Params Parms{}; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function GeometryCache.GeometryCacheComponent.GetPlaybackSpeed // (Final, Native, Public, BlueprintCallable, BlueprintPure, Const) // Parameters: // float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) float UGeometryCacheComponent::GetPlaybackSpeed() { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("GeometryCacheComponent", "GetPlaybackSpeed"); Params::UGeometryCacheComponent_GetPlaybackSpeed_Params Parms{}; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function GeometryCache.GeometryCacheComponent.GetPlaybackDirection // (Final, Native, Public, BlueprintCallable, BlueprintPure, Const) // Parameters: // float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) float UGeometryCacheComponent::GetPlaybackDirection() { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("GeometryCacheComponent", "GetPlaybackDirection"); Params::UGeometryCacheComponent_GetPlaybackDirection_Params Parms{}; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function GeometryCache.GeometryCacheComponent.GetOverrideWireframeColor // (Final, Native, Public, BlueprintCallable, BlueprintPure, Const) // Parameters: // bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) bool UGeometryCacheComponent::GetOverrideWireframeColor() { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("GeometryCacheComponent", "GetOverrideWireframeColor"); Params::UGeometryCacheComponent_GetOverrideWireframeColor_Params Parms{}; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function GeometryCache.GeometryCacheComponent.GetNumberOfFrames // (Final, Native, Public, BlueprintCallable, BlueprintPure, Const) // Parameters: // int32 ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) int32 UGeometryCacheComponent::GetNumberOfFrames() { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("GeometryCacheComponent", "GetNumberOfFrames"); Params::UGeometryCacheComponent_GetNumberOfFrames_Params Parms{}; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function GeometryCache.GeometryCacheComponent.GetMotionVectorScale // (Final, Native, Public, BlueprintCallable, BlueprintPure, Const) // Parameters: // float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) float UGeometryCacheComponent::GetMotionVectorScale() { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("GeometryCacheComponent", "GetMotionVectorScale"); Params::UGeometryCacheComponent_GetMotionVectorScale_Params Parms{}; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function GeometryCache.GeometryCacheComponent.GetDuration // (Final, Native, Public, BlueprintCallable, BlueprintPure, Const) // Parameters: // float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) float UGeometryCacheComponent::GetDuration() { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("GeometryCacheComponent", "GetDuration"); Params::UGeometryCacheComponent_GetDuration_Params Parms{}; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Function GeometryCache.GeometryCacheComponent.GetAnimationTime // (Final, Native, Public, BlueprintCallable, BlueprintPure, Const) // Parameters: // float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) float UGeometryCacheComponent::GetAnimationTime() { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("GeometryCacheComponent", "GetAnimationTime"); Params::UGeometryCacheComponent_GetAnimationTime_Params Parms{}; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; return Parms.ReturnValue; } // Class GeometryCache.GeometryCacheTrack // (None) class UClass* UGeometryCacheTrack::StaticClass() { static class UClass* Clss = nullptr; if (!Clss) Clss = UObject::FindClassFast("GeometryCacheTrack"); return Clss; } // GeometryCacheTrack GeometryCache.Default__GeometryCacheTrack // (Public, ClassDefaultObject, ArchetypeObject) class UGeometryCacheTrack* UGeometryCacheTrack::GetDefaultObj() { static class UGeometryCacheTrack* Default = nullptr; if (!Default) Default = static_cast(UGeometryCacheTrack::StaticClass()->DefaultObject); return Default; } // Class GeometryCache.GeometryCacheTrack_FlipbookAnimation // (None) class UClass* UGeometryCacheTrack_FlipbookAnimation::StaticClass() { static class UClass* Clss = nullptr; if (!Clss) Clss = UObject::FindClassFast("GeometryCacheTrack_FlipbookAnimation"); return Clss; } // GeometryCacheTrack_FlipbookAnimation GeometryCache.Default__GeometryCacheTrack_FlipbookAnimation // (Public, ClassDefaultObject, ArchetypeObject) class UGeometryCacheTrack_FlipbookAnimation* UGeometryCacheTrack_FlipbookAnimation::GetDefaultObj() { static class UGeometryCacheTrack_FlipbookAnimation* Default = nullptr; if (!Default) Default = static_cast(UGeometryCacheTrack_FlipbookAnimation::StaticClass()->DefaultObject); return Default; } // Function GeometryCache.GeometryCacheTrack_FlipbookAnimation.AddMeshSample // (Final, Native, Public, HasOutParams) // Parameters: // struct FGeometryCacheMeshData MeshData (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic) // float SampleTime (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic) void UGeometryCacheTrack_FlipbookAnimation::AddMeshSample(struct FGeometryCacheMeshData& MeshData, float SampleTime) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("GeometryCacheTrack_FlipbookAnimation", "AddMeshSample"); Params::UGeometryCacheTrack_FlipbookAnimation_AddMeshSample_Params Parms{}; Parms.MeshData = MeshData; Parms.SampleTime = SampleTime; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; } // Class GeometryCache.GeometryCacheTrackStreamable // (None) class UClass* UGeometryCacheTrackStreamable::StaticClass() { static class UClass* Clss = nullptr; if (!Clss) Clss = UObject::FindClassFast("GeometryCacheTrackStreamable"); return Clss; } // GeometryCacheTrackStreamable GeometryCache.Default__GeometryCacheTrackStreamable // (Public, ClassDefaultObject, ArchetypeObject) class UGeometryCacheTrackStreamable* UGeometryCacheTrackStreamable::GetDefaultObj() { static class UGeometryCacheTrackStreamable* Default = nullptr; if (!Default) Default = static_cast(UGeometryCacheTrackStreamable::StaticClass()->DefaultObject); return Default; } // Class GeometryCache.GeometryCacheTrack_TransformAnimation // (None) class UClass* UGeometryCacheTrack_TransformAnimation::StaticClass() { static class UClass* Clss = nullptr; if (!Clss) Clss = UObject::FindClassFast("GeometryCacheTrack_TransformAnimation"); return Clss; } // GeometryCacheTrack_TransformAnimation GeometryCache.Default__GeometryCacheTrack_TransformAnimation // (Public, ClassDefaultObject, ArchetypeObject) class UGeometryCacheTrack_TransformAnimation* UGeometryCacheTrack_TransformAnimation::GetDefaultObj() { static class UGeometryCacheTrack_TransformAnimation* Default = nullptr; if (!Default) Default = static_cast(UGeometryCacheTrack_TransformAnimation::StaticClass()->DefaultObject); return Default; } // Function GeometryCache.GeometryCacheTrack_TransformAnimation.SetMesh // (Final, Native, Public, HasOutParams) // Parameters: // struct FGeometryCacheMeshData NewMeshData (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic) void UGeometryCacheTrack_TransformAnimation::SetMesh(struct FGeometryCacheMeshData& NewMeshData) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("GeometryCacheTrack_TransformAnimation", "SetMesh"); Params::UGeometryCacheTrack_TransformAnimation_SetMesh_Params Parms{}; Parms.NewMeshData = NewMeshData; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; } // Class GeometryCache.GeometryCacheTrack_TransformGroupAnimation // (None) class UClass* UGeometryCacheTrack_TransformGroupAnimation::StaticClass() { static class UClass* Clss = nullptr; if (!Clss) Clss = UObject::FindClassFast("GeometryCacheTrack_TransformGroupAnimation"); return Clss; } // GeometryCacheTrack_TransformGroupAnimation GeometryCache.Default__GeometryCacheTrack_TransformGroupAnimation // (Public, ClassDefaultObject, ArchetypeObject) class UGeometryCacheTrack_TransformGroupAnimation* UGeometryCacheTrack_TransformGroupAnimation::GetDefaultObj() { static class UGeometryCacheTrack_TransformGroupAnimation* Default = nullptr; if (!Default) Default = static_cast(UGeometryCacheTrack_TransformGroupAnimation::StaticClass()->DefaultObject); return Default; } // Function GeometryCache.GeometryCacheTrack_TransformGroupAnimation.SetMesh // (Final, Native, Public, HasOutParams) // Parameters: // struct FGeometryCacheMeshData NewMeshData (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic) void UGeometryCacheTrack_TransformGroupAnimation::SetMesh(struct FGeometryCacheMeshData& NewMeshData) { static class UFunction* Func = nullptr; if (!Func) Func = Class->GetFunction("GeometryCacheTrack_TransformGroupAnimation", "SetMesh"); Params::UGeometryCacheTrack_TransformGroupAnimation_SetMesh_Params Parms{}; Parms.NewMeshData = NewMeshData; auto Flgs = Func->FunctionFlags; Func->FunctionFlags |= 0x400; UObject::ProcessEvent(Func, &Parms); Func->FunctionFlags = Flgs; } // Class GeometryCache.NiagaraGeometryCacheRendererProperties // (None) class UClass* UNiagaraGeometryCacheRendererProperties::StaticClass() { static class UClass* Clss = nullptr; if (!Clss) Clss = UObject::FindClassFast("NiagaraGeometryCacheRendererProperties"); return Clss; } // NiagaraGeometryCacheRendererProperties GeometryCache.Default__NiagaraGeometryCacheRendererProperties // (Public, ClassDefaultObject, ArchetypeObject) class UNiagaraGeometryCacheRendererProperties* UNiagaraGeometryCacheRendererProperties::GetDefaultObj() { static class UNiagaraGeometryCacheRendererProperties* Default = nullptr; if (!Default) Default = static_cast(UNiagaraGeometryCacheRendererProperties::StaticClass()->DefaultObject); return Default; } }