#pragma once

/*
* SDK generated by Dumper-7
*
* https://github.com/Encryqed/Dumper-7
*/

// Package: Engine

#include "Basic.hpp"

#include "Engine_structs.hpp"
#include "AudioExtensions_structs.hpp"
#include "AudioExtensions_classes.hpp"
#include "CoreUObject_structs.hpp"
#include "CoreUObject_classes.hpp"
#include "PhysicsCore_structs.hpp"
#include "PhysicsCore_classes.hpp"
#include "InputCore_structs.hpp"
#include "FieldNotification_structs.hpp"
#include "AudioPlatformConfiguration_structs.hpp"
#include "Chaos_structs.hpp"
#include "DeveloperSettings_structs.hpp"
#include "DeveloperSettings_classes.hpp"
#include "SlateCore_structs.hpp"
#include "IrisCore_classes.hpp"
#include "NetCore_structs.hpp"
#include "NetCore_classes.hpp"
#include "PacketHandler_classes.hpp"
#include "MeshDescription_classes.hpp"


namespace SDK
{

// Class Engine.ActorComponent
// 0x0080 (0x00A8 - 0x0028)
class UActorComponent : public UObject
{
public:
	uint8                                         Pad_28[0x8];                                       // 0x0028(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	struct FActorComponentTickFunction            PrimaryComponentTick;                              // 0x0030(0x0038)(Edit, DisableEditOnInstance, NativeAccessSpecifierPublic)
	TArray<class FName>                           ComponentTags;                                     // 0x0068(0x0010)(Edit, BlueprintVisible, ZeroConstructor, NativeAccessSpecifierPublic)
	TArray<class UAssetUserData*>                 AssetUserData;                                     // 0x0078(0x0010)(Edit, ExportObject, ZeroConstructor, ContainsInstancedReference, AdvancedDisplay, Protected, UObjectWrapper, NativeAccessSpecifierProtected)
	uint8                                         Pad_88[0x4];                                       // 0x0088(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	int32                                         UCSSerializationIndex;                             // 0x008C(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         BitPad_90_0 : 3;                                   // 0x0090(0x0001)(Fixing Bit-Field Size Between Bits [ Dumper-7 ])
	uint8                                         bNetAddressable : 1;                               // 0x0090(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
	uint8                                         bReplicateUsingRegisteredSubObjectList : 1;        // 0x0090(0x0001)(BitIndex: 0x04, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, Config, DisableEditOnInstance, NoDestructor, AdvancedDisplay, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
	uint8                                         bReplicates : 1;                                   // 0x0090(0x0001)(BitIndex: 0x05, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, Net, DisableEditOnInstance, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate))
	uint8                                         BitPad_90_6 : 2;                                   // 0x0090(0x0001)(Fixing Bit-Field Size For New Byte [ Dumper-7 ])
	uint8                                         Pad_91[0x1];                                       // 0x0091(0x0001)(Fixing Size After Last Property [ Dumper-7 ])
	uint8                                         BitPad_92_0 : 1;                                   // 0x0092(0x0001)(Fixing Bit-Field Size Between Bits [ Dumper-7 ])
	uint8                                         bAutoActivate : 1;                                 // 0x0092(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bIsActive : 1;                                     // 0x0092(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Net, Transient, RepNotify, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate))
	uint8                                         bEditableWhenInherited : 1;                        // 0x0092(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (Edit, DisableEditOnInstance, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         BitPad_92_4 : 1;                                   // 0x0092(0x0001)(Fixing Bit-Field Size Between Bits [ Dumper-7 ])
	uint8                                         bCanEverAffectNavigation : 1;                      // 0x0092(0x0001)(BitIndex: 0x05, PropSize: 0x0001 (Edit, Config, NoDestructor, AdvancedDisplay, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
	uint8                                         BitPad_92_6 : 1;                                   // 0x0092(0x0001)(Fixing Bit-Field Size Between Bits [ Dumper-7 ])
	uint8                                         bIsEditorOnly : 1;                                 // 0x0092(0x0001)(BitIndex: 0x07, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_93[0x2];                                       // 0x0093(0x0002)(Fixing Size After Last Property [ Dumper-7 ])
	EComponentCreationMethod                      CreationMethod;                                    // 0x0095(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	FMulticastSparseDelegateProperty_             OnComponentActivated;                              // 0x0096(0x0001)(InstancedReference, BlueprintAssignable, NoDestructor, NativeAccessSpecifierPublic)
	FMulticastSparseDelegateProperty_             OnComponentDeactivated;                            // 0x0097(0x0001)(InstancedReference, BlueprintAssignable, NoDestructor, NativeAccessSpecifierPublic)
	uint8                                         Pad_98[0x10];                                      // 0x0098(0x0010)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void Activate(bool bReset);
	void AddTickPrerequisiteActor(class AActor* PrerequisiteActor);
	void AddTickPrerequisiteComponent(class UActorComponent* PrerequisiteComponent);
	void Deactivate();
	void K2_DestroyComponent(class UObject* Object);
	void OnRep_IsActive();
	void ReceiveAsyncPhysicsTick(float DeltaSeconds, float SimSeconds);
	void ReceiveBeginPlay();
	void ReceiveEndPlay(EEndPlayReason EndPlayReason);
	void ReceiveTick(float DeltaSeconds);
	void RemoveTickPrerequisiteActor(class AActor* PrerequisiteActor);
	void RemoveTickPrerequisiteComponent(class UActorComponent* PrerequisiteComponent);
	void SetActive(bool bNewActive, bool bReset);
	void SetAutoActivate(bool bNewAutoActivate);
	void SetComponentTickEnabled(bool bEnabled);
	void SetComponentTickInterval(float TickInterval);
	void SetComponentTickIntervalAndCooldown(float TickInterval);
	void SetIsReplicated(bool ShouldReplicate);
	void SetTickableWhenPaused(bool bTickableWhenPaused);
	void SetTickGroup(ETickingGroup NewTickGroup);
	void ToggleActive();

	bool ComponentHasTag(class FName Tag) const;
	float GetComponentTickInterval() const;
	class AActor* GetOwner() const;
	bool IsActive() const;
	bool IsBeingDestroyed() const;
	bool IsComponentTickEnabled() const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ActorComponent">();
	}
	static class UActorComponent* GetDefaultObj()
	{
		return GetDefaultObjImpl<UActorComponent>();
	}
};
static_assert(alignof(UActorComponent) == 0x000008, "Wrong alignment on UActorComponent");
static_assert(sizeof(UActorComponent) == 0x0000A8, "Wrong size on UActorComponent");
static_assert(offsetof(UActorComponent, PrimaryComponentTick) == 0x000030, "Member 'UActorComponent::PrimaryComponentTick' has a wrong offset!");
static_assert(offsetof(UActorComponent, ComponentTags) == 0x000068, "Member 'UActorComponent::ComponentTags' has a wrong offset!");
static_assert(offsetof(UActorComponent, AssetUserData) == 0x000078, "Member 'UActorComponent::AssetUserData' has a wrong offset!");
static_assert(offsetof(UActorComponent, UCSSerializationIndex) == 0x00008C, "Member 'UActorComponent::UCSSerializationIndex' has a wrong offset!");
static_assert(offsetof(UActorComponent, CreationMethod) == 0x000095, "Member 'UActorComponent::CreationMethod' has a wrong offset!");
static_assert(offsetof(UActorComponent, OnComponentActivated) == 0x000096, "Member 'UActorComponent::OnComponentActivated' has a wrong offset!");
static_assert(offsetof(UActorComponent, OnComponentDeactivated) == 0x000097, "Member 'UActorComponent::OnComponentDeactivated' has a wrong offset!");

// Class Engine.SceneComponent
// 0x01F8 (0x02A0 - 0x00A8)
class alignas(0x10) USceneComponent : public UActorComponent
{
public:
	uint8                                         Pad_A8[0x8];                                       // 0x00A8(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	TWeakObjectPtr<class APhysicsVolume>          PhysicsVolume;                                     // 0x00B0(0x0008)(ZeroConstructor, Transient, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	class USceneComponent*                        AttachParent;                                      // 0x00B8(0x0008)(ExportObject, Net, ZeroConstructor, InstancedReference, RepNotify, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	class FName                                   AttachSocketName;                                  // 0x00C0(0x0008)(Net, ZeroConstructor, IsPlainOldData, RepNotify, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	TArray<class USceneComponent*>                AttachChildren;                                    // 0x00C8(0x0010)(ExportObject, Net, ZeroConstructor, Transient, RepNotify, ContainsInstancedReference, UObjectWrapper, NativeAccessSpecifierPrivate)
	TArray<class USceneComponent*>                ClientAttachedChildren;                            // 0x00D8(0x0010)(ExportObject, ZeroConstructor, Transient, ContainsInstancedReference, UObjectWrapper, NativeAccessSpecifierPrivate)
	uint8                                         Pad_E8[0x48];                                      // 0x00E8(0x0048)(Fixing Size After Last Property [ Dumper-7 ])
	struct FVector                                RelativeLocation;                                  // 0x0130(0x0018)(Edit, BlueprintVisible, BlueprintReadOnly, Net, ZeroConstructor, IsPlainOldData, RepNotify, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	struct FRotator                               RelativeRotation;                                  // 0x0148(0x0018)(Edit, BlueprintVisible, BlueprintReadOnly, Net, ZeroConstructor, IsPlainOldData, RepNotify, NoDestructor, NativeAccessSpecifierPrivate)
	struct FVector                                RelativeScale3D;                                   // 0x0160(0x0018)(Edit, BlueprintVisible, BlueprintReadOnly, Net, ZeroConstructor, IsPlainOldData, RepNotify, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	struct FVector                                ComponentVelocity;                                 // 0x0178(0x0018)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bComponentToWorldUpdated : 1;                      // 0x0190(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Transient, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate))
	uint8                                         BitPad_190_1 : 1;                                  // 0x0190(0x0001)(Fixing Bit-Field Size Between Bits [ Dumper-7 ])
	uint8                                         bAbsoluteLocation : 1;                             // 0x0190(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Edit, BlueprintVisible, Net, RepNotify, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPrivate))
	uint8                                         bAbsoluteRotation : 1;                             // 0x0190(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (Edit, BlueprintVisible, Net, RepNotify, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPrivate))
	uint8                                         bAbsoluteScale : 1;                                // 0x0190(0x0001)(BitIndex: 0x04, PropSize: 0x0001 (Edit, BlueprintVisible, Net, RepNotify, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPrivate))
	uint8                                         bVisible : 1;                                      // 0x0190(0x0001)(BitIndex: 0x05, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, Net, RepNotify, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate))
	uint8                                         bShouldBeAttached : 1;                             // 0x0190(0x0001)(BitIndex: 0x06, PropSize: 0x0001 (Net, Transient, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate))
	uint8                                         bShouldSnapLocationWhenAttached : 1;               // 0x0190(0x0001)(BitIndex: 0x07, PropSize: 0x0001 (Net, Transient, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate))
	uint8                                         bShouldSnapRotationWhenAttached : 1;               // 0x0191(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Net, Transient, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate))
	uint8                                         bShouldSnapScaleWhenAttached : 1;                  // 0x0191(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Net, Transient, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate))
	uint8                                         bShouldUpdatePhysicsVolume : 1;                    // 0x0191(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPrivate))
	uint8                                         bHiddenInGame : 1;                                 // 0x0191(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bBoundsChangeTriggersStreamingDataRebuild : 1;     // 0x0191(0x0001)(BitIndex: 0x04, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bUseAttachParentBound : 1;                         // 0x0191(0x0001)(BitIndex: 0x05, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bComputeFastLocalBounds : 1;                       // 0x0191(0x0001)(BitIndex: 0x06, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bComputeBoundsOnceForGame : 1;                     // 0x0191(0x0001)(BitIndex: 0x07, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bComputedBoundsOnceForGame : 1;                    // 0x0192(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bIsNotRenderAttachmentRoot : 1;                    // 0x0192(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	EComponentMobility                            Mobility;                                          // 0x0193(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, Net, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EDetailMode                                   DetailMode;                                        // 0x0194(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	FMulticastSparseDelegateProperty_             PhysicsVolumeChangedDelegate;                      // 0x0195(0x0001)(InstancedReference, BlueprintAssignable, NoDestructor, NativeAccessSpecifierPublic)
	uint8                                         Pad_196[0x10A];                                    // 0x0196(0x010A)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void DetachFromParent(bool bMaintainWorldPosition, bool bCallModify);
	void K2_AddLocalOffset(const struct FVector& DeltaLocation, bool bSweep, struct FHitResult* SweepHitResult, bool bTeleport);
	void K2_AddLocalRotation(const struct FRotator& DeltaRotation, bool bSweep, struct FHitResult* SweepHitResult, bool bTeleport);
	void K2_AddLocalTransform(const struct FTransform& DeltaTransform, bool bSweep, struct FHitResult* SweepHitResult, bool bTeleport);
	void K2_AddRelativeLocation(const struct FVector& DeltaLocation, bool bSweep, struct FHitResult* SweepHitResult, bool bTeleport);
	void K2_AddRelativeRotation(const struct FRotator& DeltaRotation, bool bSweep, struct FHitResult* SweepHitResult, bool bTeleport);
	void K2_AddWorldOffset(const struct FVector& DeltaLocation, bool bSweep, struct FHitResult* SweepHitResult, bool bTeleport);
	void K2_AddWorldRotation(const struct FRotator& DeltaRotation, bool bSweep, struct FHitResult* SweepHitResult, bool bTeleport);
	void K2_AddWorldTransform(const struct FTransform& DeltaTransform, bool bSweep, struct FHitResult* SweepHitResult, bool bTeleport);
	void K2_AddWorldTransformKeepScale(const struct FTransform& DeltaTransform, bool bSweep, struct FHitResult* SweepHitResult, bool bTeleport);
	bool K2_AttachTo(class USceneComponent* InParent, class FName InSocketName, EAttachLocation AttachType, bool bWeldSimulatedBodies);
	bool K2_AttachToComponent(class USceneComponent* Parent, class FName SocketName, EAttachmentRule LocationRule, EAttachmentRule RotationRule, EAttachmentRule ScaleRule, bool bWeldSimulatedBodies);
	void K2_DetachFromComponent(EDetachmentRule LocationRule, EDetachmentRule RotationRule, EDetachmentRule ScaleRule, bool bCallModify);
	void K2_SetRelativeLocation(const struct FVector& NewLocation, bool bSweep, struct FHitResult* SweepHitResult, bool bTeleport);
	void K2_SetRelativeLocationAndRotation(const struct FVector& NewLocation, const struct FRotator& NewRotation, bool bSweep, struct FHitResult* SweepHitResult, bool bTeleport);
	void K2_SetRelativeRotation(const struct FRotator& NewRotation, bool bSweep, struct FHitResult* SweepHitResult, bool bTeleport);
	void K2_SetRelativeTransform(const struct FTransform& NewTransform, bool bSweep, struct FHitResult* SweepHitResult, bool bTeleport);
	void K2_SetWorldLocation(const struct FVector& NewLocation, bool bSweep, struct FHitResult* SweepHitResult, bool bTeleport);
	void K2_SetWorldLocationAndRotation(const struct FVector& NewLocation, const struct FRotator& NewRotation, bool bSweep, struct FHitResult* SweepHitResult, bool bTeleport);
	void K2_SetWorldRotation(const struct FRotator& NewRotation, bool bSweep, struct FHitResult* SweepHitResult, bool bTeleport);
	void K2_SetWorldTransform(const struct FTransform& NewTransform, bool bSweep, struct FHitResult* SweepHitResult, bool bTeleport);
	void OnRep_AttachChildren();
	void OnRep_AttachParent();
	void OnRep_AttachSocketName();
	void OnRep_Transform();
	void OnRep_Visibility(bool OldValue);
	void ResetRelativeTransform();
	void SetAbsolute(bool bNewAbsoluteLocation, bool bNewAbsoluteRotation, bool bNewAbsoluteScale);
	void SetHiddenInGame(bool NewHidden, bool bPropagateToChildren);
	void SetMobility(EComponentMobility NewMobility);
	void SetRelativeScale3D(const struct FVector& NewScale3D);
	void SetShouldUpdatePhysicsVolume(bool bInShouldUpdatePhysicsVolume);
	void SetVisibility(bool bNewVisibility, bool bPropagateToChildren);
	void SetWorldScale3D(const struct FVector& NewScale);
	void ToggleVisibility(bool bPropagateToChildren);

	bool DoesSocketExist(class FName InSocketName) const;
	TArray<class FName> GetAllSocketNames() const;
	class USceneComponent* GetAttachParent() const;
	class FName GetAttachSocketName() const;
	class USceneComponent* GetChildComponent(int32 ChildIndex) const;
	void GetChildrenComponents(bool bIncludeAllDescendants, TArray<class USceneComponent*>* Children) const;
	struct FVector GetComponentVelocity() const;
	struct FVector GetForwardVector() const;
	int32 GetNumChildrenComponents() const;
	void GetParentComponents(TArray<class USceneComponent*>* Parents) const;
	class APhysicsVolume* GetPhysicsVolume() const;
	struct FTransform GetRelativeTransform() const;
	struct FVector GetRightVector() const;
	bool GetShouldUpdatePhysicsVolume() const;
	struct FVector GetSocketLocation(class FName InSocketName) const;
	struct FQuat GetSocketQuaternion(class FName InSocketName) const;
	struct FRotator GetSocketRotation(class FName InSocketName) const;
	struct FTransform GetSocketTransform(class FName InSocketName, ERelativeTransformSpace TransformSpace) const;
	struct FVector GetUpVector() const;
	bool IsAnySimulatingPhysics() const;
	bool IsSimulatingPhysics(class FName BoneName) const;
	bool IsVisible() const;
	struct FVector K2_GetComponentLocation() const;
	struct FRotator K2_GetComponentRotation() const;
	struct FVector K2_GetComponentScale() const;
	struct FTransform K2_GetComponentToWorld() const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"SceneComponent">();
	}
	static class USceneComponent* GetDefaultObj()
	{
		return GetDefaultObjImpl<USceneComponent>();
	}
};
static_assert(alignof(USceneComponent) == 0x000010, "Wrong alignment on USceneComponent");
static_assert(sizeof(USceneComponent) == 0x0002A0, "Wrong size on USceneComponent");
static_assert(offsetof(USceneComponent, PhysicsVolume) == 0x0000B0, "Member 'USceneComponent::PhysicsVolume' has a wrong offset!");
static_assert(offsetof(USceneComponent, AttachParent) == 0x0000B8, "Member 'USceneComponent::AttachParent' has a wrong offset!");
static_assert(offsetof(USceneComponent, AttachSocketName) == 0x0000C0, "Member 'USceneComponent::AttachSocketName' has a wrong offset!");
static_assert(offsetof(USceneComponent, AttachChildren) == 0x0000C8, "Member 'USceneComponent::AttachChildren' has a wrong offset!");
static_assert(offsetof(USceneComponent, ClientAttachedChildren) == 0x0000D8, "Member 'USceneComponent::ClientAttachedChildren' has a wrong offset!");
static_assert(offsetof(USceneComponent, RelativeLocation) == 0x000130, "Member 'USceneComponent::RelativeLocation' has a wrong offset!");
static_assert(offsetof(USceneComponent, RelativeRotation) == 0x000148, "Member 'USceneComponent::RelativeRotation' has a wrong offset!");
static_assert(offsetof(USceneComponent, RelativeScale3D) == 0x000160, "Member 'USceneComponent::RelativeScale3D' has a wrong offset!");
static_assert(offsetof(USceneComponent, ComponentVelocity) == 0x000178, "Member 'USceneComponent::ComponentVelocity' has a wrong offset!");
static_assert(offsetof(USceneComponent, Mobility) == 0x000193, "Member 'USceneComponent::Mobility' has a wrong offset!");
static_assert(offsetof(USceneComponent, DetailMode) == 0x000194, "Member 'USceneComponent::DetailMode' has a wrong offset!");
static_assert(offsetof(USceneComponent, PhysicsVolumeChangedDelegate) == 0x000195, "Member 'USceneComponent::PhysicsVolumeChangedDelegate' has a wrong offset!");

// Class Engine.ReflectionCaptureComponent
// 0x0070 (0x0310 - 0x02A0)
class UReflectionCaptureComponent : public USceneComponent
{
public:
	class UBillboardComponent*                    CaptureOffsetComponent;                            // 0x02A0(0x0008)(ExportObject, ZeroConstructor, InstancedReference, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EReflectionSourceType                         ReflectionSourceType;                              // 0x02A8(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_2A9[0x7];                                      // 0x02A9(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	class UTextureCube*                           Cubemap;                                           // 0x02B0(0x0008)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         SourceCubemapAngle;                                // 0x02B8(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         Brightness;                                        // 0x02BC(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector                                CaptureOffset;                                     // 0x02C0(0x0018)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FGuid                                  MapBuildDataId;                                    // 0x02D8(0x0010)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_2E8[0x28];                                     // 0x02E8(0x0028)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ReflectionCaptureComponent">();
	}
	static class UReflectionCaptureComponent* GetDefaultObj()
	{
		return GetDefaultObjImpl<UReflectionCaptureComponent>();
	}
};
static_assert(alignof(UReflectionCaptureComponent) == 0x000010, "Wrong alignment on UReflectionCaptureComponent");
static_assert(sizeof(UReflectionCaptureComponent) == 0x000310, "Wrong size on UReflectionCaptureComponent");
static_assert(offsetof(UReflectionCaptureComponent, CaptureOffsetComponent) == 0x0002A0, "Member 'UReflectionCaptureComponent::CaptureOffsetComponent' has a wrong offset!");
static_assert(offsetof(UReflectionCaptureComponent, ReflectionSourceType) == 0x0002A8, "Member 'UReflectionCaptureComponent::ReflectionSourceType' has a wrong offset!");
static_assert(offsetof(UReflectionCaptureComponent, Cubemap) == 0x0002B0, "Member 'UReflectionCaptureComponent::Cubemap' has a wrong offset!");
static_assert(offsetof(UReflectionCaptureComponent, SourceCubemapAngle) == 0x0002B8, "Member 'UReflectionCaptureComponent::SourceCubemapAngle' has a wrong offset!");
static_assert(offsetof(UReflectionCaptureComponent, Brightness) == 0x0002BC, "Member 'UReflectionCaptureComponent::Brightness' has a wrong offset!");
static_assert(offsetof(UReflectionCaptureComponent, CaptureOffset) == 0x0002C0, "Member 'UReflectionCaptureComponent::CaptureOffset' has a wrong offset!");
static_assert(offsetof(UReflectionCaptureComponent, MapBuildDataId) == 0x0002D8, "Member 'UReflectionCaptureComponent::MapBuildDataId' has a wrong offset!");

// Class Engine.MaterialExpression
// 0x0088 (0x00B0 - 0x0028)
class UMaterialExpression : public UObject
{
public:
	int32                                         MaterialExpressionEditorX;                         // 0x0028(0x0004)(BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         MaterialExpressionEditorY;                         // 0x002C(0x0004)(BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UEdGraphNode*                           GraphNode;                                         // 0x0030(0x0008)(ZeroConstructor, Transient, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UMaterialExpression*                    SubgraphExpression;                                // 0x0038(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_40[0x10];                                      // 0x0040(0x0010)(Fixing Size After Last Property [ Dumper-7 ])
	struct FGuid                                  MaterialExpressionGuid;                            // 0x0050(0x0010)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UMaterial*                              Material;                                          // 0x0060(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UMaterialFunction*                      Function;                                          // 0x0068(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FString                                 Desc;                                              // 0x0070(0x0010)(Edit, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_80[0x4];                                       // 0x0080(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	uint8                                         bRealtimePreview : 1;                              // 0x0084(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bNeedToUpdatePreview : 1;                          // 0x0084(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Transient, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         BitPad_84_2 : 6;                                   // 0x0084(0x0001)(Fixing Bit-Field Size For New Byte [ Dumper-7 ])
	uint8                                         Pad_85[0x3];                                       // 0x0085(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	uint8                                         bIsParameterExpression : 1;                        // 0x0088(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         BitPad_88_1 : 7;                                   // 0x0088(0x0001)(Fixing Bit-Field Size For New Byte [ Dumper-7 ])
	uint8                                         Pad_89[0x3];                                       // 0x0089(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	uint8                                         bCommentBubbleVisible : 1;                         // 0x008C(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bShowOutputNameOnPin : 1;                          // 0x008C(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bShowMaskColorsOnPin : 1;                          // 0x008C(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bHidePreviewWindow : 1;                            // 0x008C(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bCollapsed : 1;                                    // 0x008C(0x0001)(BitIndex: 0x04, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bShaderInputData : 1;                              // 0x008C(0x0001)(BitIndex: 0x05, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bShowInputs : 1;                                   // 0x008C(0x0001)(BitIndex: 0x06, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bShowOutputs : 1;                                  // 0x008C(0x0001)(BitIndex: 0x07, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_8D[0x3];                                       // 0x008D(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<class FText>                           MenuCategories;                                    // 0x0090(0x0010)(ZeroConstructor, NativeAccessSpecifierPublic)
	TArray<struct FExpressionOutput>              Outputs;                                           // 0x00A0(0x0010)(ZeroConstructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpression">();
	}
	static class UMaterialExpression* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpression>();
	}
};
static_assert(alignof(UMaterialExpression) == 0x000008, "Wrong alignment on UMaterialExpression");
static_assert(sizeof(UMaterialExpression) == 0x0000B0, "Wrong size on UMaterialExpression");
static_assert(offsetof(UMaterialExpression, MaterialExpressionEditorX) == 0x000028, "Member 'UMaterialExpression::MaterialExpressionEditorX' has a wrong offset!");
static_assert(offsetof(UMaterialExpression, MaterialExpressionEditorY) == 0x00002C, "Member 'UMaterialExpression::MaterialExpressionEditorY' has a wrong offset!");
static_assert(offsetof(UMaterialExpression, GraphNode) == 0x000030, "Member 'UMaterialExpression::GraphNode' has a wrong offset!");
static_assert(offsetof(UMaterialExpression, SubgraphExpression) == 0x000038, "Member 'UMaterialExpression::SubgraphExpression' has a wrong offset!");
static_assert(offsetof(UMaterialExpression, MaterialExpressionGuid) == 0x000050, "Member 'UMaterialExpression::MaterialExpressionGuid' has a wrong offset!");
static_assert(offsetof(UMaterialExpression, Material) == 0x000060, "Member 'UMaterialExpression::Material' has a wrong offset!");
static_assert(offsetof(UMaterialExpression, Function) == 0x000068, "Member 'UMaterialExpression::Function' has a wrong offset!");
static_assert(offsetof(UMaterialExpression, Desc) == 0x000070, "Member 'UMaterialExpression::Desc' has a wrong offset!");
static_assert(offsetof(UMaterialExpression, MenuCategories) == 0x000090, "Member 'UMaterialExpression::MenuCategories' has a wrong offset!");
static_assert(offsetof(UMaterialExpression, Outputs) == 0x0000A0, "Member 'UMaterialExpression::Outputs' has a wrong offset!");

// Class Engine.MaterialExpressionExponential2
// 0x0028 (0x00D8 - 0x00B0)
class UMaterialExpressionExponential2 final : public UMaterialExpression
{
public:
	struct FExpressionInput                       Input;                                             // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionExponential2">();
	}
	static class UMaterialExpressionExponential2* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionExponential2>();
	}
};
static_assert(alignof(UMaterialExpressionExponential2) == 0x000008, "Wrong alignment on UMaterialExpressionExponential2");
static_assert(sizeof(UMaterialExpressionExponential2) == 0x0000D8, "Wrong size on UMaterialExpressionExponential2");
static_assert(offsetof(UMaterialExpressionExponential2, Input) == 0x0000B0, "Member 'UMaterialExpressionExponential2::Input' has a wrong offset!");

// Class Engine.SoundSubmixBase
// 0x0018 (0x0040 - 0x0028)
class USoundSubmixBase : public UObject
{
public:
	bool                                          bAutoDisable;                                      // 0x0028(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_29[0x3];                                       // 0x0029(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         AutoDisableTime;                                   // 0x002C(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TArray<class USoundSubmixBase*>               ChildSubmixes;                                     // 0x0030(0x0010)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, EditConst, UObjectWrapper, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"SoundSubmixBase">();
	}
	static class USoundSubmixBase* GetDefaultObj()
	{
		return GetDefaultObjImpl<USoundSubmixBase>();
	}
};
static_assert(alignof(USoundSubmixBase) == 0x000008, "Wrong alignment on USoundSubmixBase");
static_assert(sizeof(USoundSubmixBase) == 0x000040, "Wrong size on USoundSubmixBase");
static_assert(offsetof(USoundSubmixBase, bAutoDisable) == 0x000028, "Member 'USoundSubmixBase::bAutoDisable' has a wrong offset!");
static_assert(offsetof(USoundSubmixBase, AutoDisableTime) == 0x00002C, "Member 'USoundSubmixBase::AutoDisableTime' has a wrong offset!");
static_assert(offsetof(USoundSubmixBase, ChildSubmixes) == 0x000030, "Member 'USoundSubmixBase::ChildSubmixes' has a wrong offset!");

// Class Engine.SoundSubmixWithParentBase
// 0x0008 (0x0048 - 0x0040)
class USoundSubmixWithParentBase : public USoundSubmixBase
{
public:
	class USoundSubmixBase*                       ParentSubmix;                                      // 0x0040(0x0008)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, EditConst, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"SoundSubmixWithParentBase">();
	}
	static class USoundSubmixWithParentBase* GetDefaultObj()
	{
		return GetDefaultObjImpl<USoundSubmixWithParentBase>();
	}
};
static_assert(alignof(USoundSubmixWithParentBase) == 0x000008, "Wrong alignment on USoundSubmixWithParentBase");
static_assert(sizeof(USoundSubmixWithParentBase) == 0x000048, "Wrong size on USoundSubmixWithParentBase");
static_assert(offsetof(USoundSubmixWithParentBase, ParentSubmix) == 0x000040, "Member 'USoundSubmixWithParentBase::ParentSubmix' has a wrong offset!");

// Class Engine.SoundSubmix
// 0x0168 (0x01B0 - 0x0048)
class USoundSubmix final : public USoundSubmixWithParentBase
{
public:
	uint8                                         bMuteWhenBackgrounded : 1;                         // 0x0048(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_49[0x7];                                       // 0x0049(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<class USoundEffectSubmixPreset*>       SubmixEffectChain;                                 // 0x0050(0x0010)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, UObjectWrapper, NativeAccessSpecifierPublic)
	class USoundfieldEncodingSettingsBase*        AmbisonicsPluginSettings;                          // 0x0060(0x0008)(Edit, BlueprintVisible, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         EnvelopeFollowerAttackTime;                        // 0x0068(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         EnvelopeFollowerReleaseTime;                       // 0x006C(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         OutputVolume;                                      // 0x0070(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         WetLevel;                                          // 0x0074(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         DryLevel;                                          // 0x0078(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_7C[0x4];                                       // 0x007C(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	struct FSoundModulationDestinationSettings    OutputVolumeModulation;                            // 0x0080(0x0058)(Edit, BlueprintVisible, NativeAccessSpecifierPublic)
	struct FSoundModulationDestinationSettings    WetLevelModulation;                                // 0x00D8(0x0058)(Edit, BlueprintVisible, NativeAccessSpecifierPublic)
	struct FSoundModulationDestinationSettings    DryLevelModulation;                                // 0x0130(0x0058)(Edit, BlueprintVisible, NativeAccessSpecifierPublic)
	uint8                                         bSendToAudioLink : 1;                              // 0x0188(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_189[0x7];                                      // 0x0189(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	class UAudioLinkSettingsAbstract*             AudioLinkSettings;                                 // 0x0190(0x0008)(Edit, BlueprintVisible, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TMulticastInlineDelegate<void(const class USoundWave* ResultingSoundWave)> OnSubmixRecordedFileDone; // 0x0198(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	uint8                                         Pad_1A8[0x8];                                      // 0x01A8(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void AddEnvelopeFollowerDelegate(const class UObject* WorldContextObject, const TDelegate<void(const TArray<float>& Envelope)>& OnSubmixEnvelopeBP);
	void AddSpectralAnalysisDelegate(const class UObject* WorldContextObject, const TArray<struct FSoundSubmixSpectralAnalysisBandSettings>& InBandSettings, const TDelegate<void(const TArray<float>& Magnitude)>& OnSubmixSpectralAnalysisBP, float UpdateRate, float DecibelNoiseFloor, bool bDoNormalize, bool bDoAutoRange, float AutoRangeAttackTime, float AutoRangeReleaseTime);
	void RemoveSpectralAnalysisDelegate(const class UObject* WorldContextObject, const TDelegate<void(const TArray<float>& Magnitude)>& OnSubmixSpectralAnalysisBP);
	void SetDryVolumeModulation(const struct FSoundModulationDestinationSettings& InVolMod);
	void SetOutputVolumeModulation(const struct FSoundModulationDestinationSettings& InVolMod);
	void SetSubmixDryLevel(const class UObject* WorldContextObject, float InDryLevel);
	void SetSubmixOutputVolume(const class UObject* WorldContextObject, float InOutputVolume);
	void SetSubmixWetLevel(const class UObject* WorldContextObject, float InWetLevel);
	void SetWetVolumeModulation(const struct FSoundModulationDestinationSettings& InVolMod);
	void StartEnvelopeFollowing(const class UObject* WorldContextObject);
	void StartRecordingOutput(const class UObject* WorldContextObject, float ExpectedDuration);
	void StartSpectralAnalysis(const class UObject* WorldContextObject, EFFTSize FFTSize, EFFTPeakInterpolationMethod InterpolationMethod, EFFTWindowType WindowType, float HopSize, EAudioSpectrumType SpectrumType);
	void StopEnvelopeFollowing(const class UObject* WorldContextObject);
	void StopRecordingOutput(const class UObject* WorldContextObject, EAudioRecordingExportType ExportType, const class FString& Name_0, const class FString& Path, class USoundWave* ExistingSoundWaveToOverwrite);
	void StopSpectralAnalysis(const class UObject* WorldContextObject);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"SoundSubmix">();
	}
	static class USoundSubmix* GetDefaultObj()
	{
		return GetDefaultObjImpl<USoundSubmix>();
	}
};
static_assert(alignof(USoundSubmix) == 0x000008, "Wrong alignment on USoundSubmix");
static_assert(sizeof(USoundSubmix) == 0x0001B0, "Wrong size on USoundSubmix");
static_assert(offsetof(USoundSubmix, SubmixEffectChain) == 0x000050, "Member 'USoundSubmix::SubmixEffectChain' has a wrong offset!");
static_assert(offsetof(USoundSubmix, AmbisonicsPluginSettings) == 0x000060, "Member 'USoundSubmix::AmbisonicsPluginSettings' has a wrong offset!");
static_assert(offsetof(USoundSubmix, EnvelopeFollowerAttackTime) == 0x000068, "Member 'USoundSubmix::EnvelopeFollowerAttackTime' has a wrong offset!");
static_assert(offsetof(USoundSubmix, EnvelopeFollowerReleaseTime) == 0x00006C, "Member 'USoundSubmix::EnvelopeFollowerReleaseTime' has a wrong offset!");
static_assert(offsetof(USoundSubmix, OutputVolume) == 0x000070, "Member 'USoundSubmix::OutputVolume' has a wrong offset!");
static_assert(offsetof(USoundSubmix, WetLevel) == 0x000074, "Member 'USoundSubmix::WetLevel' has a wrong offset!");
static_assert(offsetof(USoundSubmix, DryLevel) == 0x000078, "Member 'USoundSubmix::DryLevel' has a wrong offset!");
static_assert(offsetof(USoundSubmix, OutputVolumeModulation) == 0x000080, "Member 'USoundSubmix::OutputVolumeModulation' has a wrong offset!");
static_assert(offsetof(USoundSubmix, WetLevelModulation) == 0x0000D8, "Member 'USoundSubmix::WetLevelModulation' has a wrong offset!");
static_assert(offsetof(USoundSubmix, DryLevelModulation) == 0x000130, "Member 'USoundSubmix::DryLevelModulation' has a wrong offset!");
static_assert(offsetof(USoundSubmix, AudioLinkSettings) == 0x000190, "Member 'USoundSubmix::AudioLinkSettings' has a wrong offset!");
static_assert(offsetof(USoundSubmix, OnSubmixRecordedFileDone) == 0x000198, "Member 'USoundSubmix::OnSubmixRecordedFileDone' has a wrong offset!");

// Class Engine.Actor
// 0x0278 (0x02A0 - 0x0028)
class AActor : public UObject
{
public:
	struct FActorTickFunction                     PrimaryActorTick;                                  // 0x0028(0x0038)(Edit, DisableEditOnInstance, NativeAccessSpecifierPublic)
	uint8                                         bNetTemporary : 1;                                 // 0x0060(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         BitPad_60_1 : 1;                                   // 0x0060(0x0001)(Fixing Bit-Field Size Between Bits [ Dumper-7 ])
	uint8                                         bOnlyRelevantToOwner : 1;                          // 0x0060(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, DisableEditOnInstance, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bAlwaysRelevant : 1;                               // 0x0060(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (Edit, BlueprintVisible, DisableEditOnInstance, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bReplicateMovement : 1;                            // 0x0060(0x0001)(BitIndex: 0x04, PropSize: 0x0001 (Edit, Net, DisableEditOnInstance, RepNotify, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate))
	uint8                                         bCallPreReplication : 1;                           // 0x0060(0x0001)(BitIndex: 0x05, PropSize: 0x0001 (Edit, DisableEditOnInstance, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPrivate))
	uint8                                         bCallPreReplicationForReplay : 1;                  // 0x0060(0x0001)(BitIndex: 0x06, PropSize: 0x0001 (Edit, DisableEditOnInstance, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPrivate))
	uint8                                         bHidden : 1;                                       // 0x0060(0x0001)(BitIndex: 0x07, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, Net, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate))
	uint8                                         bTearOff : 1;                                      // 0x0061(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Net, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate))
	uint8                                         bForceNetAddressable : 1;                          // 0x0061(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate))
	uint8                                         bExchangedRoles : 1;                               // 0x0061(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Transient, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bNetLoadOnClient : 1;                              // 0x0061(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bNetUseOwnerRelevancy : 1;                         // 0x0061(0x0001)(BitIndex: 0x04, PropSize: 0x0001 (Edit, BlueprintVisible, DisableEditOnInstance, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bRelevantForNetworkReplays : 1;                    // 0x0061(0x0001)(BitIndex: 0x05, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bRelevantForLevelBounds : 1;                       // 0x0061(0x0001)(BitIndex: 0x06, PropSize: 0x0001 (Edit, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bReplayRewindable : 1;                             // 0x0061(0x0001)(BitIndex: 0x07, PropSize: 0x0001 (Edit, DisableEditOnInstance, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bAllowTickBeforeBeginPlay : 1;                     // 0x0062(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, DisableEditOnInstance, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bAutoDestroyWhenFinished : 1;                      // 0x0062(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate))
	uint8                                         bCanBeDamaged : 1;                                 // 0x0062(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Edit, BlueprintVisible, Net, SaveGame, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate))
	uint8                                         bBlockInput : 1;                                   // 0x0062(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (Edit, DisableEditOnInstance, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bCollideWhenPlacing : 1;                           // 0x0062(0x0001)(BitIndex: 0x04, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bFindCameraComponentWhenViewTarget : 1;            // 0x0062(0x0001)(BitIndex: 0x05, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bGenerateOverlapEventsDuringLevelStreaming : 1;    // 0x0062(0x0001)(BitIndex: 0x06, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bIgnoresOriginShifting : 1;                        // 0x0062(0x0001)(BitIndex: 0x07, PropSize: 0x0001 (Edit, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bEnableAutoLODGeneration : 1;                      // 0x0063(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bIsEditorOnlyActor : 1;                            // 0x0063(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bActorSeamlessTraveled : 1;                        // 0x0063(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bReplicates : 1;                                   // 0x0063(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, DisableEditOnInstance, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
	uint8                                         bCanBeInCluster : 1;                               // 0x0063(0x0001)(BitIndex: 0x04, PropSize: 0x0001 (Edit, NoDestructor, AdvancedDisplay, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
	uint8                                         bAllowReceiveTickEventOnDedicatedServer : 1;       // 0x0063(0x0001)(BitIndex: 0x05, PropSize: 0x0001 (NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
	uint8                                         BitPad_63_6 : 1;                                   // 0x0063(0x0001)(Fixing Bit-Field Size Between Bits [ Dumper-7 ])
	uint8                                         bReplicateUsingRegisteredSubObjectList : 1;        // 0x0063(0x0001)(BitIndex: 0x07, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, Config, DisableEditOnInstance, NoDestructor, AdvancedDisplay, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
	uint8                                         BitPad_64_0 : 7;                                   // 0x0064(0x0001)(Fixing Bit-Field Size Between Bits [ Dumper-7 ])
	uint8                                         bActorEnableCollision : 1;                         // 0x0064(0x0001)(BitIndex: 0x07, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate))
	uint8                                         bActorIsBeingDestroyed : 1;                        // 0x0065(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Transient, DuplicateTransient, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate))
	uint8                                         BitPad_65_1 : 4;                                   // 0x0065(0x0001)(Fixing Bit-Field Size Between Bits [ Dumper-7 ])
	uint8                                         bAsyncPhysicsTickEnabled : 1;                      // 0x0065(0x0001)(BitIndex: 0x05, PropSize: 0x0001 (Edit, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
	EActorUpdateOverlapsMethod                    UpdateOverlapsMethodDuringLevelStreaming;          // 0x0066(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	EActorUpdateOverlapsMethod                    DefaultUpdateOverlapsMethodDuringLevelStreaming;   // 0x0067(0x0001)(Edit, ZeroConstructor, Config, EditConst, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	float                                         InitialLifeSpan;                                   // 0x0068(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         CustomTimeDilation;                                // 0x006C(0x0004)(BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	ENetRole                                      RemoteRole;                                        // 0x0070(0x0001)(Edit, Net, ZeroConstructor, DisableEditOnTemplate, Transient, EditConst, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_71[0x3];                                       // 0x0071(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	int32                                         RayTracingGroupId;                                 // 0x0074(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	struct FRepAttachment                         AttachmentReplication;                             // 0x0078(0x0060)(Net, Transient, RepNotify, NoDestructor, ContainsInstancedReference, Protected, NativeAccessSpecifierProtected)
	struct FRepMovement                           ReplicatedMovement;                                // 0x00D8(0x0070)(Edit, Net, DisableEditOnInstance, RepNotify, NoDestructor, AdvancedDisplay, NativeAccessSpecifierPrivate)
	class AActor*                                 Owner;                                             // 0x0148(0x0008)(Net, ZeroConstructor, RepNotify, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FName                                   NetDriverName;                                     // 0x0150(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	ENetRole                                      Role;                                              // 0x0158(0x0001)(Edit, Net, ZeroConstructor, DisableEditOnTemplate, EditConst, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	ENetDormancy                                  NetDormancy;                                       // 0x0159(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	ESpawnActorCollisionHandlingMethod            SpawnCollisionHandlingMethod;                      // 0x015A(0x0001)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EAutoReceiveInput                             AutoReceiveInput;                                  // 0x015B(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         InputPriority;                                     // 0x015C(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_160[0x8];                                      // 0x0160(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	class UInputComponent*                        InputComponent;                                    // 0x0168(0x0008)(ExportObject, ZeroConstructor, InstancedReference, DuplicateTransient, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         NetCullDistanceSquared;                            // 0x0170(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         NetTag;                                            // 0x0174(0x0004)(ZeroConstructor, Transient, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         NetUpdateFrequency;                                // 0x0178(0x0004)(Edit, BlueprintVisible, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         MinNetUpdateFrequency;                             // 0x017C(0x0004)(Edit, BlueprintVisible, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         NetPriority;                                       // 0x0180(0x0004)(Edit, BlueprintVisible, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EPhysicsReplicationMode                       PhysicsReplicationMode;                            // 0x0184(0x0001)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_185[0xB];                                      // 0x0185(0x000B)(Fixing Size After Last Property [ Dumper-7 ])
	class APawn*                                  Instigator;                                        // 0x0190(0x0008)(BlueprintVisible, Net, ZeroConstructor, RepNotify, NoDestructor, ExposeOnSpawn, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	TArray<class AActor*>                         Children;                                          // 0x0198(0x0010)(ZeroConstructor, Transient, UObjectWrapper, NativeAccessSpecifierPublic)
	class USceneComponent*                        RootComponent;                                     // 0x01A8(0x0008)(BlueprintVisible, ExportObject, BlueprintReadOnly, ZeroConstructor, InstancedReference, NoDestructor, Protected, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_1B0[0x8];                                      // 0x01B0(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<class FName>                           Layers;                                            // 0x01B8(0x0010)(Edit, ZeroConstructor, AdvancedDisplay, NativeAccessSpecifierPublic)
	TWeakObjectPtr<class UChildActorComponent>    ParentComponent;                                   // 0x01C8(0x0008)(ExportObject, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	TArray<class FName>                           Tags;                                              // 0x01D0(0x0010)(Edit, BlueprintVisible, ZeroConstructor, AdvancedDisplay, NativeAccessSpecifierPublic)
	FMulticastSparseDelegateProperty_             OnTakeAnyDamage;                                   // 0x01E0(0x0001)(InstancedReference, BlueprintAssignable, NoDestructor, NativeAccessSpecifierPublic)
	FMulticastSparseDelegateProperty_             OnTakePointDamage;                                 // 0x01E1(0x0001)(InstancedReference, BlueprintAssignable, NoDestructor, NativeAccessSpecifierPublic)
	FMulticastSparseDelegateProperty_             OnTakeRadialDamage;                                // 0x01E2(0x0001)(InstancedReference, BlueprintAssignable, NoDestructor, NativeAccessSpecifierPublic)
	FMulticastSparseDelegateProperty_             OnActorBeginOverlap;                               // 0x01E3(0x0001)(InstancedReference, BlueprintAssignable, NoDestructor, NativeAccessSpecifierPublic)
	FMulticastSparseDelegateProperty_             OnActorEndOverlap;                                 // 0x01E4(0x0001)(InstancedReference, BlueprintAssignable, NoDestructor, NativeAccessSpecifierPublic)
	FMulticastSparseDelegateProperty_             OnBeginCursorOver;                                 // 0x01E5(0x0001)(InstancedReference, BlueprintAssignable, NoDestructor, NativeAccessSpecifierPublic)
	FMulticastSparseDelegateProperty_             OnEndCursorOver;                                   // 0x01E6(0x0001)(InstancedReference, BlueprintAssignable, NoDestructor, NativeAccessSpecifierPublic)
	FMulticastSparseDelegateProperty_             OnClicked;                                         // 0x01E7(0x0001)(InstancedReference, BlueprintAssignable, NoDestructor, NativeAccessSpecifierPublic)
	FMulticastSparseDelegateProperty_             OnReleased;                                        // 0x01E8(0x0001)(InstancedReference, BlueprintAssignable, NoDestructor, NativeAccessSpecifierPublic)
	FMulticastSparseDelegateProperty_             OnInputTouchBegin;                                 // 0x01E9(0x0001)(InstancedReference, BlueprintAssignable, NoDestructor, NativeAccessSpecifierPublic)
	FMulticastSparseDelegateProperty_             OnInputTouchEnd;                                   // 0x01EA(0x0001)(InstancedReference, BlueprintAssignable, NoDestructor, NativeAccessSpecifierPublic)
	FMulticastSparseDelegateProperty_             OnInputTouchEnter;                                 // 0x01EB(0x0001)(InstancedReference, BlueprintAssignable, NoDestructor, NativeAccessSpecifierPublic)
	FMulticastSparseDelegateProperty_             OnInputTouchLeave;                                 // 0x01EC(0x0001)(InstancedReference, BlueprintAssignable, NoDestructor, NativeAccessSpecifierPublic)
	FMulticastSparseDelegateProperty_             OnActorHit;                                        // 0x01ED(0x0001)(InstancedReference, BlueprintAssignable, NoDestructor, NativeAccessSpecifierPublic)
	FMulticastSparseDelegateProperty_             OnDestroyed;                                       // 0x01EE(0x0001)(InstancedReference, BlueprintAssignable, NoDestructor, NativeAccessSpecifierPublic)
	FMulticastSparseDelegateProperty_             OnEndPlay;                                         // 0x01EF(0x0001)(InstancedReference, BlueprintAssignable, NoDestructor, NativeAccessSpecifierPublic)
	uint8                                         Pad_1F0[0x80];                                     // 0x01F0(0x0080)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<class UActorComponent*>                InstanceComponents;                                // 0x0270(0x0010)(ExportObject, ZeroConstructor, ContainsInstancedReference, UObjectWrapper, NativeAccessSpecifierPrivate)
	TArray<class UActorComponent*>                BlueprintCreatedComponents;                        // 0x0280(0x0010)(ExportObject, ZeroConstructor, NonTransactional, ContainsInstancedReference, TextExportTransient, UObjectWrapper, NativeAccessSpecifierPublic)
	uint8                                         Pad_290[0x10];                                     // 0x0290(0x0010)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	class UActorComponent* AddComponent(class FName TemplateName, bool bManualAttachment, const struct FTransform& RelativeTransform, const class UObject* ComponentTemplateContext, bool bDeferredFinish);
	class UActorComponent* AddComponentByClass(TSubclassOf<class UActorComponent> Class_0, bool bManualAttachment, const struct FTransform& RelativeTransform, bool bDeferredFinish);
	void AddTickPrerequisiteActor(class AActor* PrerequisiteActor);
	void AddTickPrerequisiteComponent(class UActorComponent* PrerequisiteComponent);
	void CreateInputComponent(TSubclassOf<class UInputComponent> InputComponentToCreate);
	void DetachRootComponentFromParent(bool bMaintainWorldPosition);
	void DisableInput(class APlayerController* PlayerController);
	void EnableInput(class APlayerController* PlayerController);
	void FinishAddComponent(class UActorComponent* Component, bool bManualAttachment, const struct FTransform& RelativeTransform);
	void FlushNetDormancy();
	void ForceNetUpdate();
	EPhysicsReplicationMode GetPhysicsReplicationMode();
	bool GetTickableWhenPaused();
	void K2_AddActorLocalOffset(const struct FVector& DeltaLocation, bool bSweep, struct FHitResult* SweepHitResult, bool bTeleport);
	void K2_AddActorLocalRotation(const struct FRotator& DeltaRotation, bool bSweep, struct FHitResult* SweepHitResult, bool bTeleport);
	void K2_AddActorLocalTransform(const struct FTransform& NewTransform, bool bSweep, struct FHitResult* SweepHitResult, bool bTeleport);
	void K2_AddActorWorldOffset(const struct FVector& DeltaLocation, bool bSweep, struct FHitResult* SweepHitResult, bool bTeleport);
	void K2_AddActorWorldRotation(const struct FRotator& DeltaRotation, bool bSweep, struct FHitResult* SweepHitResult, bool bTeleport);
	void K2_AddActorWorldTransform(const struct FTransform& DeltaTransform, bool bSweep, struct FHitResult* SweepHitResult, bool bTeleport);
	void K2_AddActorWorldTransformKeepScale(const struct FTransform& DeltaTransform, bool bSweep, struct FHitResult* SweepHitResult, bool bTeleport);
	void K2_AttachRootComponentTo(class USceneComponent* InParent, class FName InSocketName, EAttachLocation AttachLocationType, bool bWeldSimulatedBodies);
	void K2_AttachRootComponentToActor(class AActor* InParentActor, class FName InSocketName, EAttachLocation AttachLocationType, bool bWeldSimulatedBodies);
	bool K2_AttachToActor(class AActor* ParentActor, class FName SocketName, EAttachmentRule LocationRule, EAttachmentRule RotationRule, EAttachmentRule ScaleRule, bool bWeldSimulatedBodies);
	bool K2_AttachToComponent(class USceneComponent* Parent, class FName SocketName, EAttachmentRule LocationRule, EAttachmentRule RotationRule, EAttachmentRule ScaleRule, bool bWeldSimulatedBodies);
	void K2_DestroyActor();
	void K2_DetachFromActor(EDetachmentRule LocationRule, EDetachmentRule RotationRule, EDetachmentRule ScaleRule);
	void K2_OnBecomeViewTarget(class APlayerController* PC);
	void K2_OnEndViewTarget(class APlayerController* PC);
	void K2_OnReset();
	bool K2_SetActorLocation(const struct FVector& NewLocation, bool bSweep, struct FHitResult* SweepHitResult, bool bTeleport);
	bool K2_SetActorLocationAndRotation(const struct FVector& NewLocation, const struct FRotator& NewRotation, bool bSweep, struct FHitResult* SweepHitResult, bool bTeleport);
	void K2_SetActorRelativeLocation(const struct FVector& NewRelativeLocation, bool bSweep, struct FHitResult* SweepHitResult, bool bTeleport);
	void K2_SetActorRelativeRotation(const struct FRotator& NewRelativeRotation, bool bSweep, struct FHitResult* SweepHitResult, bool bTeleport);
	void K2_SetActorRelativeTransform(const struct FTransform& NewRelativeTransform, bool bSweep, struct FHitResult* SweepHitResult, bool bTeleport);
	bool K2_SetActorRotation(const struct FRotator& NewRotation, bool bTeleportPhysics);
	bool K2_SetActorTransform(const struct FTransform& NewTransform, bool bSweep, struct FHitResult* SweepHitResult, bool bTeleport);
	bool K2_TeleportTo(const struct FVector& DestLocation, const struct FRotator& DestRotation);
	void MakeNoise(float Loudness, class APawn* NoiseInstigator, const struct FVector& NoiseLocation, float MaxRange, class FName Tag);
	void OnRep_AttachmentReplication();
	void OnRep_Instigator();
	void OnRep_Owner();
	void OnRep_ReplicatedMovement();
	void OnRep_ReplicateMovement();
	void PrestreamTextures(float Seconds, bool bEnableStreaming, int32 CinematicTextureGroups);
	void ReceiveActorBeginCursorOver();
	void ReceiveActorBeginOverlap(class AActor* OtherActor);
	void ReceiveActorEndCursorOver();
	void ReceiveActorEndOverlap(class AActor* OtherActor);
	void ReceiveActorOnClicked(const struct FKey& ButtonPressed);
	void ReceiveActorOnInputTouchBegin(const ETouchIndex FingerIndex);
	void ReceiveActorOnInputTouchEnd(const ETouchIndex FingerIndex);
	void ReceiveActorOnInputTouchEnter(const ETouchIndex FingerIndex);
	void ReceiveActorOnInputTouchLeave(const ETouchIndex FingerIndex);
	void ReceiveActorOnReleased(const struct FKey& ButtonReleased);
	void ReceiveAnyDamage(float Damage, const class UDamageType* DamageType, class AController* InstigatedBy, class AActor* DamageCauser);
	void ReceiveAsyncPhysicsTick(float DeltaSeconds, float SimSeconds);
	void ReceiveBeginPlay();
	void ReceiveDestroyed();
	void ReceiveEndPlay(EEndPlayReason EndPlayReason);
	void ReceiveHit(class UPrimitiveComponent* MyComp, class AActor* Other, class UPrimitiveComponent* OtherComp, bool bSelfMoved, const struct FVector& HitLocation, const struct FVector& HitNormal, const struct FVector& NormalImpulse, const struct FHitResult& Hit);
	void ReceivePointDamage(float Damage, const class UDamageType* DamageType, const struct FVector& HitLocation, const struct FVector& HitNormal, class UPrimitiveComponent* HitComponent, class FName BoneName, const struct FVector& ShotFromDirection, class AController* InstigatedBy, class AActor* DamageCauser, const struct FHitResult& HitInfo);
	void ReceiveRadialDamage(float DamageReceived, const class UDamageType* DamageType, const struct FVector& Origin, const struct FHitResult& HitInfo, class AController* InstigatedBy, class AActor* DamageCauser);
	void ReceiveTick(float DeltaSeconds);
	void RemoveTickPrerequisiteActor(class AActor* PrerequisiteActor);
	void RemoveTickPrerequisiteComponent(class UActorComponent* PrerequisiteComponent);
	void SetActorEnableCollision(bool bNewActorEnableCollision);
	void SetActorHiddenInGame(bool bNewHidden);
	void SetActorRelativeScale3D(const struct FVector& NewRelativeScale);
	void SetActorScale3D(const struct FVector& NewScale3D);
	void SetActorTickEnabled(bool bEnabled);
	void SetActorTickInterval(float TickInterval);
	void SetAutoDestroyWhenFinished(bool bVal);
	void SetLifeSpan(float InLifespan);
	void SetNetDormancy(ENetDormancy NewDormancy);
	void SetOwner(class AActor* NewOwner);
	void SetPhysicsReplicationMode(const EPhysicsReplicationMode ReplicationMode);
	void SetRayTracingGroupId(int32 InRaytracingGroupId);
	void SetReplicateMovement(bool bInReplicateMovement);
	void SetReplicates(bool bInReplicates);
	void SetTickableWhenPaused(bool bTickableWhenPaused);
	void SetTickGroup(ETickingGroup NewTickGroup);
	void TearOff();
	void UserConstructionScript();

	bool ActorHasTag(class FName Tag) const;
	bool CanTriggerResimulation() const;
	class UActorComponent* FindComponentByTag(TSubclassOf<class UActorComponent> ComponentClass, class FName Tag) const;
	void GetActorBounds(bool bOnlyCollidingComponents, struct FVector* Origin, struct FVector* BoxExtent, bool bIncludeFromChildActors) const;
	bool GetActorEnableCollision() const;
	void GetActorEyesViewPoint(struct FVector* OutLocation, struct FRotator* OutRotation) const;
	struct FVector GetActorForwardVector() const;
	struct FVector GetActorRelativeScale3D() const;
	struct FVector GetActorRightVector() const;
	struct FVector GetActorScale3D() const;
	float GetActorTickInterval() const;
	float GetActorTimeDilation() const;
	struct FVector GetActorUpVector() const;
	void GetAllChildActors(TArray<class AActor*>* ChildActors, bool bIncludeDescendants) const;
	void GetAttachedActors(TArray<class AActor*>* OutActors, bool bResetArray, bool bRecursivelyIncludeAttachedActors) const;
	class AActor* GetAttachParentActor() const;
	class FName GetAttachParentSocketName() const;
	class UActorComponent* GetComponentByClass(TSubclassOf<class UActorComponent> ComponentClass) const;
	TArray<class UActorComponent*> GetComponentsByInterface(TSubclassOf<class IInterface> Interface) const;
	TArray<class UActorComponent*> GetComponentsByTag(TSubclassOf<class UActorComponent> ComponentClass, class FName Tag) const;
	float GetDistanceTo(const class AActor* OtherActor) const;
	float GetDotProductTo(const class AActor* OtherActor) const;
	float GetGameTimeSinceCreation() const;
	float GetHorizontalDistanceTo(const class AActor* OtherActor) const;
	float GetHorizontalDotProductTo(const class AActor* OtherActor) const;
	float GetInputAxisKeyValue(const struct FKey& InputAxisKey) const;
	float GetInputAxisValue(const class FName InputAxisName) const;
	struct FVector GetInputVectorAxisValue(const struct FKey& InputAxisKey) const;
	class APawn* GetInstigator() const;
	class AController* GetInstigatorController() const;
	class ULevel* GetLevel() const;
	struct FTransform GetLevelTransform() const;
	float GetLifeSpan() const;
	ENetRole GetLocalRole() const;
	void GetOverlappingActors(TArray<class AActor*>* OverlappingActors, TSubclassOf<class AActor> ClassFilter) const;
	void GetOverlappingComponents(TArray<class UPrimitiveComponent*>* OverlappingComponents) const;
	class AActor* GetOwner() const;
	class AActor* GetParentActor() const;
	class UChildActorComponent* GetParentComponent() const;
	int32 GetRayTracingGroupId() const;
	ENetRole GetRemoteRole() const;
	float GetResimulationThreshold() const;
	float GetSquaredDistanceTo(const class AActor* OtherActor) const;
	float GetSquaredHorizontalDistanceTo(const class AActor* OtherActor) const;
	const struct FTransform GetTransform() const;
	struct FVector GetVelocity() const;
	float GetVerticalDistanceTo(const class AActor* OtherActor) const;
	bool HasAuthority() const;
	bool IsActorBeingDestroyed() const;
	bool IsActorTickEnabled() const;
	bool IsChildActor() const;
	bool IsOverlappingActor(const class AActor* Other) const;
	struct FVector K2_GetActorLocation() const;
	struct FRotator K2_GetActorRotation() const;
	TArray<class UActorComponent*> K2_GetComponentsByClass(TSubclassOf<class UActorComponent> ComponentClass) const;
	class USceneComponent* K2_GetRootComponent() const;
	bool WasRecentlyRendered(float Tolerance) const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"Actor">();
	}
	static class AActor* GetDefaultObj()
	{
		return GetDefaultObjImpl<AActor>();
	}
};
static_assert(alignof(AActor) == 0x000008, "Wrong alignment on AActor");
static_assert(sizeof(AActor) == 0x0002A0, "Wrong size on AActor");
static_assert(offsetof(AActor, PrimaryActorTick) == 0x000028, "Member 'AActor::PrimaryActorTick' has a wrong offset!");
static_assert(offsetof(AActor, UpdateOverlapsMethodDuringLevelStreaming) == 0x000066, "Member 'AActor::UpdateOverlapsMethodDuringLevelStreaming' has a wrong offset!");
static_assert(offsetof(AActor, DefaultUpdateOverlapsMethodDuringLevelStreaming) == 0x000067, "Member 'AActor::DefaultUpdateOverlapsMethodDuringLevelStreaming' has a wrong offset!");
static_assert(offsetof(AActor, InitialLifeSpan) == 0x000068, "Member 'AActor::InitialLifeSpan' has a wrong offset!");
static_assert(offsetof(AActor, CustomTimeDilation) == 0x00006C, "Member 'AActor::CustomTimeDilation' has a wrong offset!");
static_assert(offsetof(AActor, RemoteRole) == 0x000070, "Member 'AActor::RemoteRole' has a wrong offset!");
static_assert(offsetof(AActor, RayTracingGroupId) == 0x000074, "Member 'AActor::RayTracingGroupId' has a wrong offset!");
static_assert(offsetof(AActor, AttachmentReplication) == 0x000078, "Member 'AActor::AttachmentReplication' has a wrong offset!");
static_assert(offsetof(AActor, ReplicatedMovement) == 0x0000D8, "Member 'AActor::ReplicatedMovement' has a wrong offset!");
static_assert(offsetof(AActor, Owner) == 0x000148, "Member 'AActor::Owner' has a wrong offset!");
static_assert(offsetof(AActor, NetDriverName) == 0x000150, "Member 'AActor::NetDriverName' has a wrong offset!");
static_assert(offsetof(AActor, Role) == 0x000158, "Member 'AActor::Role' has a wrong offset!");
static_assert(offsetof(AActor, NetDormancy) == 0x000159, "Member 'AActor::NetDormancy' has a wrong offset!");
static_assert(offsetof(AActor, SpawnCollisionHandlingMethod) == 0x00015A, "Member 'AActor::SpawnCollisionHandlingMethod' has a wrong offset!");
static_assert(offsetof(AActor, AutoReceiveInput) == 0x00015B, "Member 'AActor::AutoReceiveInput' has a wrong offset!");
static_assert(offsetof(AActor, InputPriority) == 0x00015C, "Member 'AActor::InputPriority' has a wrong offset!");
static_assert(offsetof(AActor, InputComponent) == 0x000168, "Member 'AActor::InputComponent' has a wrong offset!");
static_assert(offsetof(AActor, NetCullDistanceSquared) == 0x000170, "Member 'AActor::NetCullDistanceSquared' has a wrong offset!");
static_assert(offsetof(AActor, NetTag) == 0x000174, "Member 'AActor::NetTag' has a wrong offset!");
static_assert(offsetof(AActor, NetUpdateFrequency) == 0x000178, "Member 'AActor::NetUpdateFrequency' has a wrong offset!");
static_assert(offsetof(AActor, MinNetUpdateFrequency) == 0x00017C, "Member 'AActor::MinNetUpdateFrequency' has a wrong offset!");
static_assert(offsetof(AActor, NetPriority) == 0x000180, "Member 'AActor::NetPriority' has a wrong offset!");
static_assert(offsetof(AActor, PhysicsReplicationMode) == 0x000184, "Member 'AActor::PhysicsReplicationMode' has a wrong offset!");
static_assert(offsetof(AActor, Instigator) == 0x000190, "Member 'AActor::Instigator' has a wrong offset!");
static_assert(offsetof(AActor, Children) == 0x000198, "Member 'AActor::Children' has a wrong offset!");
static_assert(offsetof(AActor, RootComponent) == 0x0001A8, "Member 'AActor::RootComponent' has a wrong offset!");
static_assert(offsetof(AActor, Layers) == 0x0001B8, "Member 'AActor::Layers' has a wrong offset!");
static_assert(offsetof(AActor, ParentComponent) == 0x0001C8, "Member 'AActor::ParentComponent' has a wrong offset!");
static_assert(offsetof(AActor, Tags) == 0x0001D0, "Member 'AActor::Tags' has a wrong offset!");
static_assert(offsetof(AActor, OnTakeAnyDamage) == 0x0001E0, "Member 'AActor::OnTakeAnyDamage' has a wrong offset!");
static_assert(offsetof(AActor, OnTakePointDamage) == 0x0001E1, "Member 'AActor::OnTakePointDamage' has a wrong offset!");
static_assert(offsetof(AActor, OnTakeRadialDamage) == 0x0001E2, "Member 'AActor::OnTakeRadialDamage' has a wrong offset!");
static_assert(offsetof(AActor, OnActorBeginOverlap) == 0x0001E3, "Member 'AActor::OnActorBeginOverlap' has a wrong offset!");
static_assert(offsetof(AActor, OnActorEndOverlap) == 0x0001E4, "Member 'AActor::OnActorEndOverlap' has a wrong offset!");
static_assert(offsetof(AActor, OnBeginCursorOver) == 0x0001E5, "Member 'AActor::OnBeginCursorOver' has a wrong offset!");
static_assert(offsetof(AActor, OnEndCursorOver) == 0x0001E6, "Member 'AActor::OnEndCursorOver' has a wrong offset!");
static_assert(offsetof(AActor, OnClicked) == 0x0001E7, "Member 'AActor::OnClicked' has a wrong offset!");
static_assert(offsetof(AActor, OnReleased) == 0x0001E8, "Member 'AActor::OnReleased' has a wrong offset!");
static_assert(offsetof(AActor, OnInputTouchBegin) == 0x0001E9, "Member 'AActor::OnInputTouchBegin' has a wrong offset!");
static_assert(offsetof(AActor, OnInputTouchEnd) == 0x0001EA, "Member 'AActor::OnInputTouchEnd' has a wrong offset!");
static_assert(offsetof(AActor, OnInputTouchEnter) == 0x0001EB, "Member 'AActor::OnInputTouchEnter' has a wrong offset!");
static_assert(offsetof(AActor, OnInputTouchLeave) == 0x0001EC, "Member 'AActor::OnInputTouchLeave' has a wrong offset!");
static_assert(offsetof(AActor, OnActorHit) == 0x0001ED, "Member 'AActor::OnActorHit' has a wrong offset!");
static_assert(offsetof(AActor, OnDestroyed) == 0x0001EE, "Member 'AActor::OnDestroyed' has a wrong offset!");
static_assert(offsetof(AActor, OnEndPlay) == 0x0001EF, "Member 'AActor::OnEndPlay' has a wrong offset!");
static_assert(offsetof(AActor, InstanceComponents) == 0x000270, "Member 'AActor::InstanceComponents' has a wrong offset!");
static_assert(offsetof(AActor, BlueprintCreatedComponents) == 0x000280, "Member 'AActor::BlueprintCreatedComponents' has a wrong offset!");

// Class Engine.MaterialExpressionDeriveNormalZ
// 0x0028 (0x00D8 - 0x00B0)
class UMaterialExpressionDeriveNormalZ final : public UMaterialExpression
{
public:
	struct FExpressionInput                       InXY;                                              // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionDeriveNormalZ">();
	}
	static class UMaterialExpressionDeriveNormalZ* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionDeriveNormalZ>();
	}
};
static_assert(alignof(UMaterialExpressionDeriveNormalZ) == 0x000008, "Wrong alignment on UMaterialExpressionDeriveNormalZ");
static_assert(sizeof(UMaterialExpressionDeriveNormalZ) == 0x0000D8, "Wrong size on UMaterialExpressionDeriveNormalZ");
static_assert(offsetof(UMaterialExpressionDeriveNormalZ, InXY) == 0x0000B0, "Member 'UMaterialExpressionDeriveNormalZ::InXY' has a wrong offset!");

// Class Engine.HUD
// 0x00F0 (0x0390 - 0x02A0)
class AHUD : public AActor
{
public:
	class APlayerController*                      PlayerOwner;                                       // 0x02A0(0x0008)(BlueprintVisible, BlueprintReadOnly, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bLostFocusPaused : 1;                              // 0x02A8(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (BlueprintVisible, BlueprintReadOnly, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bShowHUD : 1;                                      // 0x02A8(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bShowDebugInfo : 1;                                // 0x02A8(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_2A9[0x3];                                      // 0x02A9(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	int32                                         CurrentTargetIndex;                                // 0x02AC(0x0004)(ZeroConstructor, Transient, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bShowHitBoxDebugInfo : 1;                          // 0x02B0(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bShowOverlays : 1;                                 // 0x02B0(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bEnableDebugTextShadow : 1;                        // 0x02B0(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_2B1[0x7];                                      // 0x02B1(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<class AActor*>                         PostRenderedActors;                                // 0x02B8(0x0010)(ZeroConstructor, UObjectWrapper, NativeAccessSpecifierPublic)
	uint8                                         Pad_2C8[0x8];                                      // 0x02C8(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<class FName>                           DebugDisplay;                                      // 0x02D0(0x0010)(ZeroConstructor, Config, GlobalConfig, NativeAccessSpecifierPublic)
	TArray<class FName>                           ToggledDebugCategories;                            // 0x02E0(0x0010)(ZeroConstructor, Config, GlobalConfig, NativeAccessSpecifierPublic)
	class UCanvas*                                Canvas;                                            // 0x02F0(0x0008)(ZeroConstructor, NoDestructor, Protected, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	class UCanvas*                                DebugCanvas;                                       // 0x02F8(0x0008)(ZeroConstructor, NoDestructor, Protected, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	TArray<struct FDebugTextInfo>                 DebugTextList;                                     // 0x0300(0x0010)(ZeroConstructor, Protected, NativeAccessSpecifierProtected)
	TSubclassOf<class AActor>                     ShowDebugTargetDesiredClass;                       // 0x0310(0x0008)(ZeroConstructor, NoDestructor, Protected, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	class AActor*                                 ShowDebugTargetActor;                              // 0x0318(0x0008)(ZeroConstructor, NoDestructor, Protected, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_320[0x70];                                     // 0x0320(0x0070)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void AddDebugText(const class FString& DebugText, class AActor* SrcActor, float Duration, const struct FVector& Offset, const struct FVector& DesiredOffset, const struct FColor& TextColor, bool bSkipOverwriteCheck, bool bAbsoluteLocation, bool bKeepAttachedToActor, class UFont* InFont, float FontScale, bool bDrawShadow);
	void AddHitBox(const struct FVector2D& position, const struct FVector2D& Size, class FName InName, bool bConsumesInput, int32 Priority);
	void DrawLine(float StartScreenX, float StartScreenY, float EndScreenX, float EndScreenY, const struct FLinearColor& LineColor, float LineThickness);
	void DrawMaterial(class UMaterialInterface* Material, float ScreenX, float ScreenY, float ScreenW, float ScreenH, float MaterialU, float MaterialV, float MaterialUWidth, float MaterialVHeight, float Scale, bool bScalePosition, float Rotation, const struct FVector2D& RotPivot);
	void DrawMaterialSimple(class UMaterialInterface* Material, float ScreenX, float ScreenY, float ScreenW, float ScreenH, float Scale, bool bScalePosition);
	void DrawMaterialTriangle(class UMaterialInterface* Material, const struct FVector2D& V0_Pos, const struct FVector2D& V1_Pos, const struct FVector2D& V2_Pos, const struct FVector2D& V0_UV, const struct FVector2D& V1_UV, const struct FVector2D& V2_UV, const struct FLinearColor& V0_Color, const struct FLinearColor& V1_Color, const struct FLinearColor& V2_Color);
	void DrawRect(const struct FLinearColor& RectColor, float ScreenX, float ScreenY, float ScreenW, float ScreenH);
	void DrawText(const class FString& Text, const struct FLinearColor& TextColor, float ScreenX, float ScreenY, class UFont* Font, float Scale, bool bScalePosition);
	void DrawTexture(class UTexture* Texture, float ScreenX, float ScreenY, float ScreenW, float ScreenH, float TextureU, float TextureV, float TextureUWidth, float TextureVHeight, const struct FLinearColor& TintColor, EBlendMode BlendMode, float Scale, bool bScalePosition, float Rotation, const struct FVector2D& RotPivot);
	void DrawTextureSimple(class UTexture* Texture, float ScreenX, float ScreenY, float Scale, bool bScalePosition);
	void GetActorsInSelectionRectangle(TSubclassOf<class AActor> ClassFilter, const struct FVector2D& FirstPoint, const struct FVector2D& SecondPoint, TArray<class AActor*>* OutActors, bool bIncludeNonCollidingComponents, bool bActorMustBeFullyEnclosed);
	void NextDebugTarget();
	void PreviousDebugTarget();
	void ReceiveDrawHUD(int32 SizeX, int32 SizeY);
	void ReceiveHitBoxBeginCursorOver(const class FName BoxName);
	void ReceiveHitBoxClick(const class FName BoxName);
	void ReceiveHitBoxEndCursorOver(const class FName BoxName);
	void ReceiveHitBoxRelease(const class FName BoxName);
	void RemoveAllDebugStrings();
	void RemoveDebugText(class AActor* SrcActor, bool bLeaveDurationText);
	void ShowDebug(class FName DebugType);
	void ShowDebugForReticleTargetToggle(TSubclassOf<class AActor> DesiredClass);
	void ShowDebugToggleSubCategory(class FName Category);
	void ShowHUD();

	void Deproject(float ScreenX, float ScreenY, struct FVector* WorldPosition, struct FVector* WorldDirection) const;
	class APawn* GetOwningPawn() const;
	class APlayerController* GetOwningPlayerController() const;
	void GetTextSize(const class FString& Text, float* OutWidth, float* OutHeight, class UFont* Font, float Scale) const;
	struct FVector Project(const struct FVector& Location, bool bClampToZeroPlane) const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"HUD">();
	}
	static class AHUD* GetDefaultObj()
	{
		return GetDefaultObjImpl<AHUD>();
	}
};
static_assert(alignof(AHUD) == 0x000008, "Wrong alignment on AHUD");
static_assert(sizeof(AHUD) == 0x000390, "Wrong size on AHUD");
static_assert(offsetof(AHUD, PlayerOwner) == 0x0002A0, "Member 'AHUD::PlayerOwner' has a wrong offset!");
static_assert(offsetof(AHUD, CurrentTargetIndex) == 0x0002AC, "Member 'AHUD::CurrentTargetIndex' has a wrong offset!");
static_assert(offsetof(AHUD, PostRenderedActors) == 0x0002B8, "Member 'AHUD::PostRenderedActors' has a wrong offset!");
static_assert(offsetof(AHUD, DebugDisplay) == 0x0002D0, "Member 'AHUD::DebugDisplay' has a wrong offset!");
static_assert(offsetof(AHUD, ToggledDebugCategories) == 0x0002E0, "Member 'AHUD::ToggledDebugCategories' has a wrong offset!");
static_assert(offsetof(AHUD, Canvas) == 0x0002F0, "Member 'AHUD::Canvas' has a wrong offset!");
static_assert(offsetof(AHUD, DebugCanvas) == 0x0002F8, "Member 'AHUD::DebugCanvas' has a wrong offset!");
static_assert(offsetof(AHUD, DebugTextList) == 0x000300, "Member 'AHUD::DebugTextList' has a wrong offset!");
static_assert(offsetof(AHUD, ShowDebugTargetDesiredClass) == 0x000310, "Member 'AHUD::ShowDebugTargetDesiredClass' has a wrong offset!");
static_assert(offsetof(AHUD, ShowDebugTargetActor) == 0x000318, "Member 'AHUD::ShowDebugTargetActor' has a wrong offset!");

// Class Engine.Info
// 0x0000 (0x02A0 - 0x02A0)
class AInfo : public AActor
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"Info">();
	}
	static class AInfo* GetDefaultObj()
	{
		return GetDefaultObjImpl<AInfo>();
	}
};
static_assert(alignof(AInfo) == 0x000008, "Wrong alignment on AInfo");
static_assert(sizeof(AInfo) == 0x0002A0, "Wrong size on AInfo");

// Class Engine.SkyLight
// 0x0010 (0x02B0 - 0x02A0)
class ASkyLight final : public AInfo
{
public:
	class USkyLightComponent*                     LightComponent;                                    // 0x02A0(0x0008)(Edit, BlueprintVisible, ExportObject, BlueprintReadOnly, ZeroConstructor, EditConst, InstancedReference, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         bEnabled : 1;                                      // 0x02A8(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Net, RepNotify, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_2A9[0x7];                                      // 0x02A9(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void OnRep_bEnabled();

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"SkyLight">();
	}
	static class ASkyLight* GetDefaultObj()
	{
		return GetDefaultObjImpl<ASkyLight>();
	}
};
static_assert(alignof(ASkyLight) == 0x000008, "Wrong alignment on ASkyLight");
static_assert(sizeof(ASkyLight) == 0x0002B0, "Wrong size on ASkyLight");
static_assert(offsetof(ASkyLight, LightComponent) == 0x0002A0, "Member 'ASkyLight::LightComponent' has a wrong offset!");

// Class Engine.SoundBase
// 0x0140 (0x0168 - 0x0028)
class USoundBase : public UObject
{
public:
	uint8                                         Pad_28[0x8];                                       // 0x0028(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	class USoundClass*                            SoundClassObject;                                  // 0x0030(0x0008)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, NoDestructor, AssetRegistrySearchable, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bDebug : 1;                                        // 0x0038(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bOverrideConcurrency : 1;                          // 0x0038(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bEnableBusSends : 1;                               // 0x0038(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bEnableBaseSubmix : 1;                             // 0x0038(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bEnableSubmixSends : 1;                            // 0x0038(0x0001)(BitIndex: 0x04, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bHasDelayNode : 1;                                 // 0x0038(0x0001)(BitIndex: 0x05, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bHasConcatenatorNode : 1;                          // 0x0038(0x0001)(BitIndex: 0x06, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bBypassVolumeScaleForPriority : 1;                 // 0x0038(0x0001)(BitIndex: 0x07, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	EVirtualizationMode                           VirtualizationMode;                                // 0x0039(0x0001)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_3A[0x56];                                      // 0x003A(0x0056)(Fixing Size After Last Property [ Dumper-7 ])
	TSet<class USoundConcurrency*>                ConcurrencySet;                                    // 0x0090(0x0050)(Edit, BlueprintVisible, UObjectWrapper, NativeAccessSpecifierPublic)
	struct FSoundConcurrencySettings              ConcurrencyOverrides;                              // 0x00E0(0x0020)(Edit, BlueprintVisible, NoDestructor, NativeAccessSpecifierPublic)
	float                                         Duration;                                          // 0x0100(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, EditConst, IsPlainOldData, NoDestructor, AssetRegistrySearchable, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         MaxDistance;                                       // 0x0104(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, EditConst, IsPlainOldData, NoDestructor, AssetRegistrySearchable, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         TotalSamples;                                      // 0x0108(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, EditConst, IsPlainOldData, NoDestructor, AssetRegistrySearchable, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         Priority;                                          // 0x010C(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class USoundAttenuation*                      AttenuationSettings;                               // 0x0110(0x0008)(Edit, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class USoundSubmixBase*                       SoundSubmixObject;                                 // 0x0118(0x0008)(Edit, BlueprintVisible, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TArray<struct FSoundSubmixSendInfo>           SoundSubmixSends;                                  // 0x0120(0x0010)(Edit, BlueprintVisible, ZeroConstructor, NativeAccessSpecifierPublic)
	class USoundEffectSourcePresetChain*          SourceEffectChain;                                 // 0x0130(0x0008)(Edit, BlueprintVisible, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TArray<struct FSoundSourceBusSendInfo>        BusSends;                                          // 0x0138(0x0010)(Edit, BlueprintVisible, ZeroConstructor, NativeAccessSpecifierPublic)
	TArray<struct FSoundSourceBusSendInfo>        PreEffectBusSends;                                 // 0x0148(0x0010)(Edit, BlueprintVisible, ZeroConstructor, NativeAccessSpecifierPublic)
	TArray<class UAssetUserData*>                 AssetUserData;                                     // 0x0158(0x0010)(Edit, ExportObject, ZeroConstructor, ContainsInstancedReference, AdvancedDisplay, UObjectWrapper, NativeAccessSpecifierPublic)

public:
	bool IsAttenuationSettingsEditable() const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"SoundBase">();
	}
	static class USoundBase* GetDefaultObj()
	{
		return GetDefaultObjImpl<USoundBase>();
	}
};
static_assert(alignof(USoundBase) == 0x000008, "Wrong alignment on USoundBase");
static_assert(sizeof(USoundBase) == 0x000168, "Wrong size on USoundBase");
static_assert(offsetof(USoundBase, SoundClassObject) == 0x000030, "Member 'USoundBase::SoundClassObject' has a wrong offset!");
static_assert(offsetof(USoundBase, VirtualizationMode) == 0x000039, "Member 'USoundBase::VirtualizationMode' has a wrong offset!");
static_assert(offsetof(USoundBase, ConcurrencySet) == 0x000090, "Member 'USoundBase::ConcurrencySet' has a wrong offset!");
static_assert(offsetof(USoundBase, ConcurrencyOverrides) == 0x0000E0, "Member 'USoundBase::ConcurrencyOverrides' has a wrong offset!");
static_assert(offsetof(USoundBase, Duration) == 0x000100, "Member 'USoundBase::Duration' has a wrong offset!");
static_assert(offsetof(USoundBase, MaxDistance) == 0x000104, "Member 'USoundBase::MaxDistance' has a wrong offset!");
static_assert(offsetof(USoundBase, TotalSamples) == 0x000108, "Member 'USoundBase::TotalSamples' has a wrong offset!");
static_assert(offsetof(USoundBase, Priority) == 0x00010C, "Member 'USoundBase::Priority' has a wrong offset!");
static_assert(offsetof(USoundBase, AttenuationSettings) == 0x000110, "Member 'USoundBase::AttenuationSettings' has a wrong offset!");
static_assert(offsetof(USoundBase, SoundSubmixObject) == 0x000118, "Member 'USoundBase::SoundSubmixObject' has a wrong offset!");
static_assert(offsetof(USoundBase, SoundSubmixSends) == 0x000120, "Member 'USoundBase::SoundSubmixSends' has a wrong offset!");
static_assert(offsetof(USoundBase, SourceEffectChain) == 0x000130, "Member 'USoundBase::SourceEffectChain' has a wrong offset!");
static_assert(offsetof(USoundBase, BusSends) == 0x000138, "Member 'USoundBase::BusSends' has a wrong offset!");
static_assert(offsetof(USoundBase, PreEffectBusSends) == 0x000148, "Member 'USoundBase::PreEffectBusSends' has a wrong offset!");
static_assert(offsetof(USoundBase, AssetUserData) == 0x000158, "Member 'USoundBase::AssetUserData' has a wrong offset!");

// Class Engine.SplineMetadata
// 0x0000 (0x0028 - 0x0028)
class USplineMetadata : public UObject
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"SplineMetadata">();
	}
	static class USplineMetadata* GetDefaultObj()
	{
		return GetDefaultObjImpl<USplineMetadata>();
	}
};
static_assert(alignof(USplineMetadata) == 0x000008, "Wrong alignment on USplineMetadata");
static_assert(sizeof(USplineMetadata) == 0x000028, "Wrong size on USplineMetadata");

// Class Engine.MeshDeformer
// 0x0000 (0x0028 - 0x0028)
class UMeshDeformer : public UObject
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MeshDeformer">();
	}
	static class UMeshDeformer* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMeshDeformer>();
	}
};
static_assert(alignof(UMeshDeformer) == 0x000008, "Wrong alignment on UMeshDeformer");
static_assert(sizeof(UMeshDeformer) == 0x000028, "Wrong size on UMeshDeformer");

// Class Engine.MaterialExpressionRgbToHsv
// 0x0028 (0x00D8 - 0x00B0)
class UMaterialExpressionRgbToHsv final : public UMaterialExpression
{
public:
	struct FExpressionInput                       Input;                                             // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionRgbToHsv">();
	}
	static class UMaterialExpressionRgbToHsv* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionRgbToHsv>();
	}
};
static_assert(alignof(UMaterialExpressionRgbToHsv) == 0x000008, "Wrong alignment on UMaterialExpressionRgbToHsv");
static_assert(sizeof(UMaterialExpressionRgbToHsv) == 0x0000D8, "Wrong size on UMaterialExpressionRgbToHsv");
static_assert(offsetof(UMaterialExpressionRgbToHsv, Input) == 0x0000B0, "Member 'UMaterialExpressionRgbToHsv::Input' has a wrong offset!");

// Class Engine.BlueprintFunctionLibrary
// 0x0000 (0x0028 - 0x0028)
class UBlueprintFunctionLibrary : public UObject
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"BlueprintFunctionLibrary">();
	}
	static class UBlueprintFunctionLibrary* GetDefaultObj()
	{
		return GetDefaultObjImpl<UBlueprintFunctionLibrary>();
	}
};
static_assert(alignof(UBlueprintFunctionLibrary) == 0x000008, "Wrong alignment on UBlueprintFunctionLibrary");
static_assert(sizeof(UBlueprintFunctionLibrary) == 0x000028, "Wrong size on UBlueprintFunctionLibrary");

// Class Engine.MaterialFunctionInterface
// 0x0018 (0x0040 - 0x0028)
class UMaterialFunctionInterface : public UObject
{
public:
	struct FGuid                                  StateId;                                           // 0x0028(0x0010)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EMaterialFunctionUsage                        MaterialFunctionUsage;                             // 0x0038(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, AssetRegistrySearchable, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_39[0x7];                                       // 0x0039(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialFunctionInterface">();
	}
	static class UMaterialFunctionInterface* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialFunctionInterface>();
	}
};
static_assert(alignof(UMaterialFunctionInterface) == 0x000008, "Wrong alignment on UMaterialFunctionInterface");
static_assert(sizeof(UMaterialFunctionInterface) == 0x000040, "Wrong size on UMaterialFunctionInterface");
static_assert(offsetof(UMaterialFunctionInterface, StateId) == 0x000028, "Member 'UMaterialFunctionInterface::StateId' has a wrong offset!");
static_assert(offsetof(UMaterialFunctionInterface, MaterialFunctionUsage) == 0x000038, "Member 'UMaterialFunctionInterface::MaterialFunctionUsage' has a wrong offset!");

// Class Engine.MaterialFunctionInstance
// 0x00A0 (0x00E0 - 0x0040)
class UMaterialFunctionInstance : public UMaterialFunctionInterface
{
public:
	class UMaterialFunctionInterface*             Parent;                                            // 0x0040(0x0008)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, NoDestructor, AssetRegistrySearchable, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UMaterialFunctionInterface*             base;                                              // 0x0048(0x0008)(ZeroConstructor, NoDestructor, AssetRegistrySearchable, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TArray<struct FScalarParameterValue>          ScalarParameterValues;                             // 0x0050(0x0010)(Edit, ZeroConstructor, NativeAccessSpecifierPublic)
	TArray<struct FVectorParameterValue>          VectorParameterValues;                             // 0x0060(0x0010)(Edit, ZeroConstructor, NativeAccessSpecifierPublic)
	TArray<struct FDoubleVectorParameterValue>    DoubleVectorParameterValues;                       // 0x0070(0x0010)(Edit, ZeroConstructor, NativeAccessSpecifierPublic)
	TArray<struct FTextureParameterValue>         TextureParameterValues;                            // 0x0080(0x0010)(Edit, ZeroConstructor, NativeAccessSpecifierPublic)
	TArray<struct FFontParameterValue>            FontParameterValues;                               // 0x0090(0x0010)(Edit, ZeroConstructor, NativeAccessSpecifierPublic)
	TArray<struct FStaticSwitchParameter>         StaticSwitchParameterValues;                       // 0x00A0(0x0010)(Edit, ZeroConstructor, NativeAccessSpecifierPublic)
	TArray<struct FStaticComponentMaskParameter>  StaticComponentMaskParameterValues;                // 0x00B0(0x0010)(Edit, ZeroConstructor, NativeAccessSpecifierPublic)
	TArray<struct FRuntimeVirtualTextureParameterValue> RuntimeVirtualTextureParameterValues;        // 0x00C0(0x0010)(Edit, ZeroConstructor, NativeAccessSpecifierPublic)
	TArray<struct FSparseVolumeTextureParameterValue> SparseVolumeTextureParameterValues;            // 0x00D0(0x0010)(Edit, ZeroConstructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialFunctionInstance">();
	}
	static class UMaterialFunctionInstance* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialFunctionInstance>();
	}
};
static_assert(alignof(UMaterialFunctionInstance) == 0x000008, "Wrong alignment on UMaterialFunctionInstance");
static_assert(sizeof(UMaterialFunctionInstance) == 0x0000E0, "Wrong size on UMaterialFunctionInstance");
static_assert(offsetof(UMaterialFunctionInstance, Parent) == 0x000040, "Member 'UMaterialFunctionInstance::Parent' has a wrong offset!");
static_assert(offsetof(UMaterialFunctionInstance, base) == 0x000048, "Member 'UMaterialFunctionInstance::base' has a wrong offset!");
static_assert(offsetof(UMaterialFunctionInstance, ScalarParameterValues) == 0x000050, "Member 'UMaterialFunctionInstance::ScalarParameterValues' has a wrong offset!");
static_assert(offsetof(UMaterialFunctionInstance, VectorParameterValues) == 0x000060, "Member 'UMaterialFunctionInstance::VectorParameterValues' has a wrong offset!");
static_assert(offsetof(UMaterialFunctionInstance, DoubleVectorParameterValues) == 0x000070, "Member 'UMaterialFunctionInstance::DoubleVectorParameterValues' has a wrong offset!");
static_assert(offsetof(UMaterialFunctionInstance, TextureParameterValues) == 0x000080, "Member 'UMaterialFunctionInstance::TextureParameterValues' has a wrong offset!");
static_assert(offsetof(UMaterialFunctionInstance, FontParameterValues) == 0x000090, "Member 'UMaterialFunctionInstance::FontParameterValues' has a wrong offset!");
static_assert(offsetof(UMaterialFunctionInstance, StaticSwitchParameterValues) == 0x0000A0, "Member 'UMaterialFunctionInstance::StaticSwitchParameterValues' has a wrong offset!");
static_assert(offsetof(UMaterialFunctionInstance, StaticComponentMaskParameterValues) == 0x0000B0, "Member 'UMaterialFunctionInstance::StaticComponentMaskParameterValues' has a wrong offset!");
static_assert(offsetof(UMaterialFunctionInstance, RuntimeVirtualTextureParameterValues) == 0x0000C0, "Member 'UMaterialFunctionInstance::RuntimeVirtualTextureParameterValues' has a wrong offset!");
static_assert(offsetof(UMaterialFunctionInstance, SparseVolumeTextureParameterValues) == 0x0000D0, "Member 'UMaterialFunctionInstance::SparseVolumeTextureParameterValues' has a wrong offset!");

// Class Engine.MaterialExpressionPreSkinnedNormal
// 0x0000 (0x00B0 - 0x00B0)
class UMaterialExpressionPreSkinnedNormal final : public UMaterialExpression
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionPreSkinnedNormal">();
	}
	static class UMaterialExpressionPreSkinnedNormal* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionPreSkinnedNormal>();
	}
};
static_assert(alignof(UMaterialExpressionPreSkinnedNormal) == 0x000008, "Wrong alignment on UMaterialExpressionPreSkinnedNormal");
static_assert(sizeof(UMaterialExpressionPreSkinnedNormal) == 0x0000B0, "Wrong size on UMaterialExpressionPreSkinnedNormal");

// Class Engine.MaterialInterface
// 0x0088 (0x00B0 - 0x0028)
class UMaterialInterface : public UObject
{
public:
	uint8                                         Pad_28[0x10];                                      // 0x0028(0x0010)(Fixing Size After Last Property [ Dumper-7 ])
	class USubsurfaceProfile*                     SubsurfaceProfile;                                 // 0x0038(0x0008)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TArray<class USpecularProfile*>               SpecularProfiles;                                  // 0x0040(0x0010)(ZeroConstructor, UObjectWrapper, NativeAccessSpecifierPublic)
	uint8                                         bIncludedInBaseGame : 1;                           // 0x0050(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_51[0x17];                                      // 0x0051(0x0017)(Fixing Size After Last Property [ Dumper-7 ])
	struct FLightmassMaterialInterfaceSettings    LightmassSettings;                                 // 0x0068(0x0010)(Edit, NoDestructor, Protected, NativeAccessSpecifierProtected)
	TArray<struct FMaterialTextureInfo>           TextureStreamingData;                              // 0x0078(0x0010)(ZeroConstructor, Protected, NativeAccessSpecifierProtected)
	TArray<class UAssetUserData*>                 AssetUserData;                                     // 0x0088(0x0010)(Edit, ExportObject, ZeroConstructor, ContainsInstancedReference, AdvancedDisplay, Protected, UObjectWrapper, NativeAccessSpecifierProtected)
	uint8                                         Pad_98[0x18];                                      // 0x0098(0x0018)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	class UMaterial* GetBaseMaterial();
	void SetForceMipLevelsToBeResident(bool OverrideForceMiplevelsToBeResident, bool bForceMiplevelsToBeResidentValue, float ForceDuration, int32 CinematicTextureGroups, bool bFastResponse);

	EBlendMode GetBlendMode() const;
	class UMaterialInterface* GetNaniteOverideMaterial() const;
	struct FMaterialParameterInfo GetParameterInfo(EMaterialParameterAssociation Association, class FName ParameterName, class UMaterialFunctionInterface* LayerFunction) const;
	class UPhysicalMaterial* GetPhysicalMaterial() const;
	class UPhysicalMaterial* GetPhysicalMaterialFromMap(int32 Index_0) const;
	class UPhysicalMaterialMask* GetPhysicalMaterialMask() const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialInterface">();
	}
	static class UMaterialInterface* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialInterface>();
	}
};
static_assert(alignof(UMaterialInterface) == 0x000008, "Wrong alignment on UMaterialInterface");
static_assert(sizeof(UMaterialInterface) == 0x0000B0, "Wrong size on UMaterialInterface");
static_assert(offsetof(UMaterialInterface, SubsurfaceProfile) == 0x000038, "Member 'UMaterialInterface::SubsurfaceProfile' has a wrong offset!");
static_assert(offsetof(UMaterialInterface, SpecularProfiles) == 0x000040, "Member 'UMaterialInterface::SpecularProfiles' has a wrong offset!");
static_assert(offsetof(UMaterialInterface, LightmassSettings) == 0x000068, "Member 'UMaterialInterface::LightmassSettings' has a wrong offset!");
static_assert(offsetof(UMaterialInterface, TextureStreamingData) == 0x000078, "Member 'UMaterialInterface::TextureStreamingData' has a wrong offset!");
static_assert(offsetof(UMaterialInterface, AssetUserData) == 0x000088, "Member 'UMaterialInterface::AssetUserData' has a wrong offset!");

// Class Engine.MaterialInstance
// 0x0198 (0x0248 - 0x00B0)
class UMaterialInstance : public UMaterialInterface
{
public:
	class UPhysicalMaterial*                      PhysMaterial;                                      // 0x00B0(0x0008)(Edit, BlueprintVisible, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UPhysicalMaterial*                      PhysicalMaterialMap[0x8];                          // 0x00B8(0x0008)(Edit, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UMaterialInterface*                     Parent;                                            // 0x00F8(0x0008)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, NoDestructor, AssetRegistrySearchable, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FMaterialOverrideNanite                NaniteOverrideMaterial;                            // 0x0100(0x0038)(Edit, NativeAccessSpecifierPublic)
	uint8                                         bHasStaticPermutationResource : 1;                 // 0x0138(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bOverrideSubsurfaceProfile : 1;                    // 0x0138(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_139[0x17];                                     // 0x0139(0x0017)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<struct FScalarParameterValue>          ScalarParameterValues;                             // 0x0150(0x0010)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, NativeAccessSpecifierPublic)
	TArray<struct FVectorParameterValue>          VectorParameterValues;                             // 0x0160(0x0010)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, NativeAccessSpecifierPublic)
	TArray<struct FDoubleVectorParameterValue>    DoubleVectorParameterValues;                       // 0x0170(0x0010)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, NativeAccessSpecifierPublic)
	TArray<struct FTextureParameterValue>         TextureParameterValues;                            // 0x0180(0x0010)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, NativeAccessSpecifierPublic)
	TArray<struct FRuntimeVirtualTextureParameterValue> RuntimeVirtualTextureParameterValues;        // 0x0190(0x0010)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, NativeAccessSpecifierPublic)
	TArray<struct FSparseVolumeTextureParameterValue> SparseVolumeTextureParameterValues;            // 0x01A0(0x0010)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, NativeAccessSpecifierPublic)
	TArray<struct FFontParameterValue>            FontParameterValues;                               // 0x01B0(0x0010)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, NativeAccessSpecifierPublic)
	struct FMaterialInstanceBasePropertyOverrides BasePropertyOverrides;                             // 0x01C0(0x0014)(Edit, NoDestructor, NativeAccessSpecifierPublic)
	uint8                                         Pad_1D4[0xC];                                      // 0x01D4(0x000C)(Fixing Size After Last Property [ Dumper-7 ])
	struct FStaticParameterSetRuntimeData         StaticParametersRuntime;                           // 0x01E0(0x0038)(NativeAccessSpecifierPrivate)
	uint8                                         Pad_218[0x30];                                     // 0x0218(0x0030)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialInstance">();
	}
	static class UMaterialInstance* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialInstance>();
	}
};
static_assert(alignof(UMaterialInstance) == 0x000008, "Wrong alignment on UMaterialInstance");
static_assert(sizeof(UMaterialInstance) == 0x000248, "Wrong size on UMaterialInstance");
static_assert(offsetof(UMaterialInstance, PhysMaterial) == 0x0000B0, "Member 'UMaterialInstance::PhysMaterial' has a wrong offset!");
static_assert(offsetof(UMaterialInstance, PhysicalMaterialMap) == 0x0000B8, "Member 'UMaterialInstance::PhysicalMaterialMap' has a wrong offset!");
static_assert(offsetof(UMaterialInstance, Parent) == 0x0000F8, "Member 'UMaterialInstance::Parent' has a wrong offset!");
static_assert(offsetof(UMaterialInstance, NaniteOverrideMaterial) == 0x000100, "Member 'UMaterialInstance::NaniteOverrideMaterial' has a wrong offset!");
static_assert(offsetof(UMaterialInstance, ScalarParameterValues) == 0x000150, "Member 'UMaterialInstance::ScalarParameterValues' has a wrong offset!");
static_assert(offsetof(UMaterialInstance, VectorParameterValues) == 0x000160, "Member 'UMaterialInstance::VectorParameterValues' has a wrong offset!");
static_assert(offsetof(UMaterialInstance, DoubleVectorParameterValues) == 0x000170, "Member 'UMaterialInstance::DoubleVectorParameterValues' has a wrong offset!");
static_assert(offsetof(UMaterialInstance, TextureParameterValues) == 0x000180, "Member 'UMaterialInstance::TextureParameterValues' has a wrong offset!");
static_assert(offsetof(UMaterialInstance, RuntimeVirtualTextureParameterValues) == 0x000190, "Member 'UMaterialInstance::RuntimeVirtualTextureParameterValues' has a wrong offset!");
static_assert(offsetof(UMaterialInstance, SparseVolumeTextureParameterValues) == 0x0001A0, "Member 'UMaterialInstance::SparseVolumeTextureParameterValues' has a wrong offset!");
static_assert(offsetof(UMaterialInstance, FontParameterValues) == 0x0001B0, "Member 'UMaterialInstance::FontParameterValues' has a wrong offset!");
static_assert(offsetof(UMaterialInstance, BasePropertyOverrides) == 0x0001C0, "Member 'UMaterialInstance::BasePropertyOverrides' has a wrong offset!");
static_assert(offsetof(UMaterialInstance, StaticParametersRuntime) == 0x0001E0, "Member 'UMaterialInstance::StaticParametersRuntime' has a wrong offset!");

// Class Engine.MaterialExpressionRotateAboutAxis
// 0x00A8 (0x0158 - 0x00B0)
class UMaterialExpressionRotateAboutAxis final : public UMaterialExpression
{
public:
	struct FExpressionInput                       NormalizedRotationAxis;                            // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       RotationAngle;                                     // 0x00D8(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       PivotPoint;                                        // 0x0100(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       position;                                          // 0x0128(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	float                                         Period;                                            // 0x0150(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_154[0x4];                                      // 0x0154(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionRotateAboutAxis">();
	}
	static class UMaterialExpressionRotateAboutAxis* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionRotateAboutAxis>();
	}
};
static_assert(alignof(UMaterialExpressionRotateAboutAxis) == 0x000008, "Wrong alignment on UMaterialExpressionRotateAboutAxis");
static_assert(sizeof(UMaterialExpressionRotateAboutAxis) == 0x000158, "Wrong size on UMaterialExpressionRotateAboutAxis");
static_assert(offsetof(UMaterialExpressionRotateAboutAxis, NormalizedRotationAxis) == 0x0000B0, "Member 'UMaterialExpressionRotateAboutAxis::NormalizedRotationAxis' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionRotateAboutAxis, RotationAngle) == 0x0000D8, "Member 'UMaterialExpressionRotateAboutAxis::RotationAngle' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionRotateAboutAxis, PivotPoint) == 0x000100, "Member 'UMaterialExpressionRotateAboutAxis::PivotPoint' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionRotateAboutAxis, position) == 0x000128, "Member 'UMaterialExpressionRotateAboutAxis::position' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionRotateAboutAxis, Period) == 0x000150, "Member 'UMaterialExpressionRotateAboutAxis::Period' has a wrong offset!");

// Class Engine.KismetArrayLibrary
// 0x0000 (0x0028 - 0x0028)
class UKismetArrayLibrary final : public UBlueprintFunctionLibrary
{
public:
	static int32 Array_Add(const TArray<int32>& TargetArray, const int32& NewItem);
	static int32 Array_AddUnique(const TArray<int32>& TargetArray, const int32& NewItem);
	static void Array_Append(const TArray<int32>& TargetArray, const TArray<int32>& SourceArray);
	static void Array_Clear(const TArray<int32>& TargetArray);
	static bool Array_Contains(const TArray<int32>& TargetArray, const int32& ItemToFind);
	static int32 Array_Find(const TArray<int32>& TargetArray, const int32& ItemToFind);
	static void Array_Get(const TArray<int32>& TargetArray, int32 Index_0, int32* Item);
	static bool Array_Identical(const TArray<int32>& ArrayA, const TArray<int32>& ArrayB);
	static void Array_Insert(const TArray<int32>& TargetArray, const int32& NewItem, int32 Index_0);
	static bool Array_IsEmpty(const TArray<int32>& TargetArray);
	static bool Array_IsNotEmpty(const TArray<int32>& TargetArray);
	static bool Array_IsValidIndex(const TArray<int32>& TargetArray, int32 IndexToTest);
	static int32 Array_LastIndex(const TArray<int32>& TargetArray);
	static int32 Array_Length(const TArray<int32>& TargetArray);
	static void Array_Random(const TArray<int32>& TargetArray, int32* OutItem, int32* OutIndex);
	static void Array_RandomFromStream(const TArray<int32>& TargetArray, struct FRandomStream& RandomStream, int32* OutItem, int32* OutIndex);
	static void Array_Remove(const TArray<int32>& TargetArray, int32 IndexToRemove);
	static bool Array_RemoveItem(const TArray<int32>& TargetArray, const int32& Item);
	static void Array_Resize(const TArray<int32>& TargetArray, int32 Size);
	static void Array_Reverse(const TArray<int32>& TargetArray);
	static void Array_Set(const TArray<int32>& TargetArray, int32 Index_0, const int32& Item, bool bSizeToFit);
	static void Array_Shuffle(const TArray<int32>& TargetArray);
	static void Array_ShuffleFromStream(const TArray<int32>& TargetArray, struct FRandomStream& RandomStream);
	static void Array_Swap(const TArray<int32>& TargetArray, int32 FirstIndex, int32 SecondIndex);
	static void FilterArray(const TArray<class AActor*>& TargetArray, TSubclassOf<class AActor> FilterClass, TArray<class AActor*>* FilteredArray);
	static void SetArrayPropertyByName(class UObject* Object, class FName PropertyName, const TArray<int32>& Value);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"KismetArrayLibrary">();
	}
	static class UKismetArrayLibrary* GetDefaultObj()
	{
		return GetDefaultObjImpl<UKismetArrayLibrary>();
	}
};
static_assert(alignof(UKismetArrayLibrary) == 0x000008, "Wrong alignment on UKismetArrayLibrary");
static_assert(sizeof(UKismetArrayLibrary) == 0x000028, "Wrong size on UKismetArrayLibrary");

// Class Engine.MaterialExpressionStep
// 0x0058 (0x0108 - 0x00B0)
class UMaterialExpressionStep final : public UMaterialExpression
{
public:
	struct FExpressionInput                       Y;                                                 // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       X;                                                 // 0x00D8(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	float                                         ConstY;                                            // 0x0100(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         ConstX;                                            // 0x0104(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionStep">();
	}
	static class UMaterialExpressionStep* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionStep>();
	}
};
static_assert(alignof(UMaterialExpressionStep) == 0x000008, "Wrong alignment on UMaterialExpressionStep");
static_assert(sizeof(UMaterialExpressionStep) == 0x000108, "Wrong size on UMaterialExpressionStep");
static_assert(offsetof(UMaterialExpressionStep, Y) == 0x0000B0, "Member 'UMaterialExpressionStep::Y' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionStep, X) == 0x0000D8, "Member 'UMaterialExpressionStep::X' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionStep, ConstY) == 0x000100, "Member 'UMaterialExpressionStep::ConstY' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionStep, ConstX) == 0x000104, "Member 'UMaterialExpressionStep::ConstX' has a wrong offset!");

// Class Engine.PrimitiveComponent
// 0x02D0 (0x0570 - 0x02A0)
class UPrimitiveComponent : public USceneComponent
{
public:
	uint8                                         Pad_2A0[0x18];                                     // 0x02A0(0x0018)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         MinDrawDistance;                                   // 0x02B8(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         LDMaxDrawDistance;                                 // 0x02BC(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         CachedMaxDrawDistance;                             // 0x02C0(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, EditConst, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	ESceneDepthPriorityGroup                      DepthPriorityGroup;                                // 0x02C4(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	ESceneDepthPriorityGroup                      ViewOwnerDepthPriorityGroup;                       // 0x02C5(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EIndirectLightingCacheQuality                 IndirectLightingCacheQuality;                      // 0x02C6(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	ELightmapType                                 LightmapType;                                      // 0x02C7(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EHLODBatchingPolicy                           HLODBatchingPolicy;                                // 0x02C8(0x0001)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bEnableAutoLODGeneration : 1;                      // 0x02C9(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bIsActorTextureStreamingBuiltData : 1;             // 0x02C9(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bIsValidTextureStreamingBuiltData : 1;             // 0x02C9(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bNeverDistanceCull : 1;                            // 0x02C9(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         BitPad_2C9_4 : 4;                                  // 0x02C9(0x0001)(Fixing Bit-Field Size For New Byte [ Dumper-7 ])
	uint8                                         BitPad_2CA_0 : 2;                                  // 0x02CA(0x0001)(Fixing Bit-Field Size Between Bits [ Dumper-7 ])
	uint8                                         bAlwaysCreatePhysicsState : 1;                     // 0x02CA(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bGenerateOverlapEvents : 1;                        // 0x02CA(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate))
	uint8                                         bMultiBodyOverlap : 1;                             // 0x02CA(0x0001)(BitIndex: 0x04, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bTraceComplexOnMove : 1;                           // 0x02CA(0x0001)(BitIndex: 0x05, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bReturnMaterialOnMove : 1;                         // 0x02CA(0x0001)(BitIndex: 0x06, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bUseViewOwnerDepthPriorityGroup : 1;               // 0x02CA(0x0001)(BitIndex: 0x07, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bAllowCullDistanceVolume : 1;                      // 0x02CB(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bVisibleInReflectionCaptures : 1;                  // 0x02CB(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bVisibleInRealTimeSkyCaptures : 1;                 // 0x02CB(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bVisibleInRayTracing : 1;                          // 0x02CB(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bRenderInMainPass : 1;                             // 0x02CB(0x0001)(BitIndex: 0x04, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bRenderInDepthPass : 1;                            // 0x02CB(0x0001)(BitIndex: 0x05, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bReceivesDecals : 1;                               // 0x02CB(0x0001)(BitIndex: 0x06, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bHoldout : 1;                                      // 0x02CB(0x0001)(BitIndex: 0x07, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bOwnerNoSee : 1;                                   // 0x02CC(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bOnlyOwnerSee : 1;                                 // 0x02CC(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bTreatAsBackgroundForOcclusion : 1;                // 0x02CC(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bUseAsOccluder : 1;                                // 0x02CC(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bSelectable : 1;                                   // 0x02CC(0x0001)(BitIndex: 0x04, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bForceMipStreaming : 1;                            // 0x02CC(0x0001)(BitIndex: 0x05, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bHasPerInstanceHitProxies : 1;                     // 0x02CC(0x0001)(BitIndex: 0x06, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         CastShadow : 1;                                    // 0x02CC(0x0001)(BitIndex: 0x07, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bEmissiveLightSource : 1;                          // 0x02CD(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bAffectDynamicIndirectLighting : 1;                // 0x02CD(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, Interp, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bAffectIndirectLightingWhileHidden : 1;            // 0x02CD(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, Interp, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bAffectDistanceFieldLighting : 1;                  // 0x02CD(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bCastDynamicShadow : 1;                            // 0x02CD(0x0001)(BitIndex: 0x04, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bCastStaticShadow : 1;                             // 0x02CD(0x0001)(BitIndex: 0x05, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	EShadowCacheInvalidationBehavior              ShadowCacheInvalidationBehavior;                   // 0x02CE(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bCastVolumetricTranslucentShadow : 1;              // 0x02CF(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bCastContactShadow : 1;                            // 0x02CF(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bSelfShadowOnly : 1;                               // 0x02CF(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bCastFarShadow : 1;                                // 0x02CF(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bCastInsetShadow : 1;                              // 0x02CF(0x0001)(BitIndex: 0x04, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bCastCinematicShadow : 1;                          // 0x02CF(0x0001)(BitIndex: 0x05, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bCastHiddenShadow : 1;                             // 0x02CF(0x0001)(BitIndex: 0x06, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, Interp, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bCastShadowAsTwoSided : 1;                         // 0x02CF(0x0001)(BitIndex: 0x07, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bLightAsIfStatic : 1;                              // 0x02D0(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Deprecated, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bLightAttachmentsAsGroup : 1;                      // 0x02D0(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bExcludeFromLightAttachmentGroup : 1;              // 0x02D0(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bReceiveMobileCSMShadows : 1;                      // 0x02D0(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bSingleSampleShadowFromStationaryLights : 1;       // 0x02D0(0x0001)(BitIndex: 0x04, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bIgnoreRadialImpulse : 1;                          // 0x02D0(0x0001)(BitIndex: 0x05, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bIgnoreRadialForce : 1;                            // 0x02D0(0x0001)(BitIndex: 0x06, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bApplyImpulseOnDamage : 1;                         // 0x02D0(0x0001)(BitIndex: 0x07, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bReplicatePhysicsToAutonomousProxy : 1;            // 0x02D1(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bFillCollisionUnderneathForNavmesh : 1;            // 0x02D1(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         AlwaysLoadOnClient : 1;                            // 0x02D1(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         AlwaysLoadOnServer : 1;                            // 0x02D1(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bUseEditorCompositing : 1;                         // 0x02D1(0x0001)(BitIndex: 0x04, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bIsBeingMovedByEditor : 1;                         // 0x02D1(0x0001)(BitIndex: 0x05, PropSize: 0x0001 (Transient, DuplicateTransient, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bRenderCustomDepth : 1;                            // 0x02D1(0x0001)(BitIndex: 0x06, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bVisibleInSceneCaptureOnly : 1;                    // 0x02D1(0x0001)(BitIndex: 0x07, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bHiddenInSceneCapture : 1;                         // 0x02D2(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bRayTracingFarField : 1;                           // 0x02D2(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         BitPad_2D2_2 : 1;                                  // 0x02D2(0x0001)(Fixing Bit-Field Size Between Bits [ Dumper-7 ])
	uint8                                         bHasNoStreamableTextures : 1;                      // 0x02D2(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
	uint8                                         bStaticWhenNotMoveable : 1;                        // 0x02D2(0x0001)(BitIndex: 0x04, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, AdvancedDisplay, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
	uint8                                         Pad_2D3[0x1E];                                     // 0x02D3(0x001E)(Fixing Size After Last Property [ Dumper-7 ])
	EHasCustomNavigableGeometry                   bHasCustomNavigableGeometry;                       // 0x02F1(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_2F2[0x1];                                      // 0x02F2(0x0001)(Fixing Size After Last Property [ Dumper-7 ])
	ECanBeCharacterBase                           CanCharacterStepUpOn;                              // 0x02F3(0x0001)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FLightingChannels                      LightingChannels;                                  // 0x02F4(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, AdvancedDisplay, NativeAccessSpecifierPublic)
	uint8                                         Pad_2F5[0x3];                                      // 0x02F5(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	int32                                         RayTracingGroupId;                                 // 0x02F8(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         VisibilityId;                                      // 0x02FC(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         CustomDepthStencilValue;                           // 0x0300(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_304[0x4];                                      // 0x0304(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	struct FCustomPrimitiveData                   CustomPrimitiveData;                               // 0x0308(0x0010)(Edit, NativeAccessSpecifierPrivate)
	struct FCustomPrimitiveData                   CustomPrimitiveDataInternal;                       // 0x0318(0x0010)(Transient, NativeAccessSpecifierPrivate)
	uint8                                         Pad_328[0x8];                                      // 0x0328(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	int32                                         TranslucencySortPriority;                          // 0x0330(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         TranslucencySortDistanceOffset;                    // 0x0334(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TArray<class URuntimeVirtualTexture*>         RuntimeVirtualTextures;                            // 0x0338(0x0010)(Edit, BlueprintVisible, ZeroConstructor, UObjectWrapper, NativeAccessSpecifierPublic)
	int8                                          VirtualTextureLodBias;                             // 0x0348(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int8                                          VirtualTextureCullMips;                            // 0x0349(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int8                                          VirtualTextureMinCoverage;                         // 0x034A(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	ERuntimeVirtualTextureMainPassType            VirtualTextureRenderPassType;                      // 0x034B(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_34C[0x10];                                     // 0x034C(0x0010)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         BoundsScale;                                       // 0x035C(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_360[0x10];                                     // 0x0360(0x0010)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<class AActor*>                         MoveIgnoreActors;                                  // 0x0370(0x0010)(ZeroConstructor, Transient, DuplicateTransient, UObjectWrapper, NativeAccessSpecifierPublic)
	TArray<class UPrimitiveComponent*>            MoveIgnoreComponents;                              // 0x0380(0x0010)(ExportObject, ZeroConstructor, Transient, DuplicateTransient, ContainsInstancedReference, UObjectWrapper, NativeAccessSpecifierPublic)
	uint8                                         Pad_390[0x10];                                     // 0x0390(0x0010)(Fixing Size After Last Property [ Dumper-7 ])
	struct FBodyInstance                          BodyInstance;                                      // 0x03A0(0x0190)(Edit, BlueprintVisible, BlueprintReadOnly, NativeAccessSpecifierPublic)
	FMulticastSparseDelegateProperty_             OnComponentHit;                                    // 0x0530(0x0001)(InstancedReference, BlueprintAssignable, NoDestructor, NativeAccessSpecifierPublic)
	FMulticastSparseDelegateProperty_             OnComponentBeginOverlap;                           // 0x0531(0x0001)(InstancedReference, BlueprintAssignable, NoDestructor, NativeAccessSpecifierPublic)
	FMulticastSparseDelegateProperty_             OnComponentEndOverlap;                             // 0x0532(0x0001)(InstancedReference, BlueprintAssignable, NoDestructor, NativeAccessSpecifierPublic)
	FMulticastSparseDelegateProperty_             OnComponentWake;                                   // 0x0533(0x0001)(InstancedReference, BlueprintAssignable, NoDestructor, NativeAccessSpecifierPublic)
	FMulticastSparseDelegateProperty_             OnComponentSleep;                                  // 0x0534(0x0001)(InstancedReference, BlueprintAssignable, NoDestructor, NativeAccessSpecifierPublic)
	uint8                                         Pad_535[0x1];                                      // 0x0535(0x0001)(Fixing Size After Last Property [ Dumper-7 ])
	FMulticastSparseDelegateProperty_             OnComponentPhysicsStateChanged;                    // 0x0536(0x0001)(InstancedReference, BlueprintAssignable, NoDestructor, NativeAccessSpecifierPublic)
	FMulticastSparseDelegateProperty_             OnBeginCursorOver;                                 // 0x0537(0x0001)(InstancedReference, BlueprintAssignable, NoDestructor, NativeAccessSpecifierPublic)
	FMulticastSparseDelegateProperty_             OnEndCursorOver;                                   // 0x0538(0x0001)(InstancedReference, BlueprintAssignable, NoDestructor, NativeAccessSpecifierPublic)
	FMulticastSparseDelegateProperty_             OnClicked;                                         // 0x0539(0x0001)(InstancedReference, BlueprintAssignable, NoDestructor, NativeAccessSpecifierPublic)
	FMulticastSparseDelegateProperty_             OnReleased;                                        // 0x053A(0x0001)(InstancedReference, BlueprintAssignable, NoDestructor, NativeAccessSpecifierPublic)
	FMulticastSparseDelegateProperty_             OnInputTouchBegin;                                 // 0x053B(0x0001)(InstancedReference, BlueprintAssignable, NoDestructor, NativeAccessSpecifierPublic)
	FMulticastSparseDelegateProperty_             OnInputTouchEnd;                                   // 0x053C(0x0001)(InstancedReference, BlueprintAssignable, NoDestructor, NativeAccessSpecifierPublic)
	FMulticastSparseDelegateProperty_             OnInputTouchEnter;                                 // 0x053D(0x0001)(InstancedReference, BlueprintAssignable, NoDestructor, NativeAccessSpecifierPublic)
	FMulticastSparseDelegateProperty_             OnInputTouchLeave;                                 // 0x053E(0x0001)(InstancedReference, BlueprintAssignable, NoDestructor, NativeAccessSpecifierPublic)
	ERayTracingGroupCullingPriority               RayTracingGroupCullingPriority;                    // 0x053F(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	ERendererStencilMask                          CustomDepthStencilWriteMask;                       // 0x0540(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_541[0x1F];                                     // 0x0541(0x001F)(Fixing Size After Last Property [ Dumper-7 ])
	uint8                                         ExcludeFromHLODLevels;                             // 0x0560(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_561[0x7];                                      // 0x0561(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	class UPrimitiveComponent*                    LODParentPrimitive;                                // 0x0568(0x0008)(ExportObject, ZeroConstructor, InstancedReference, NoDestructor, NonPIEDuplicateTransient, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)

public:
	void AddAngularImpulseInDegrees(const struct FVector& Impulse, class FName BoneName, bool bVelChange);
	void AddAngularImpulseInRadians(const struct FVector& Impulse, class FName BoneName, bool bVelChange);
	void AddForce(const struct FVector& Force, class FName BoneName, bool bAccelChange);
	void AddForceAtLocation(const struct FVector& Force, const struct FVector& Location, class FName BoneName);
	void AddForceAtLocationLocal(const struct FVector& Force, const struct FVector& Location, class FName BoneName);
	void AddImpulse(const struct FVector& Impulse, class FName BoneName, bool bVelChange);
	void AddImpulseAtLocation(const struct FVector& Impulse, const struct FVector& Location, class FName BoneName);
	void AddRadialForce(const struct FVector& Origin, float Radius, float Strength, ERadialImpulseFalloff Falloff, bool bAccelChange);
	void AddRadialImpulse(const struct FVector& Origin, float Radius, float Strength, ERadialImpulseFalloff Falloff, bool bVelChange);
	void AddTorqueInDegrees(const struct FVector& Torque, class FName BoneName, bool bAccelChange);
	void AddTorqueInRadians(const struct FVector& Torque, class FName BoneName, bool bAccelChange);
	void AddVelocityChangeImpulseAtLocation(const struct FVector& Impulse, const struct FVector& Location, class FName BoneName);
	void ClearMoveIgnoreActors();
	void ClearMoveIgnoreComponents();
	TArray<class AActor*> CopyArrayOfMoveIgnoreActors();
	TArray<class UPrimitiveComponent*> CopyArrayOfMoveIgnoreComponents();
	class UMaterialInstanceDynamic* CreateAndSetMaterialInstanceDynamic(int32 ElementIndex);
	class UMaterialInstanceDynamic* CreateAndSetMaterialInstanceDynamicFromMaterial(int32 ElementIndex, class UMaterialInterface* Parent);
	class UMaterialInstanceDynamic* CreateDynamicMaterialInstance(int32 ElementIndex, class UMaterialInterface* SourceMaterial, class FName OptionalName);
	struct FVector GetPhysicsLinearVelocity(class FName BoneName);
	struct FVector GetPhysicsLinearVelocityAtPoint(const struct FVector& Point, class FName BoneName);
	void IgnoreActorWhenMoving(class AActor* Actor, bool bShouldIgnore);
	void IgnoreComponentWhenMoving(class UPrimitiveComponent* Component, bool bShouldIgnore);
	void InvalidateLumenSurfaceCache();
	bool IsAnyRigidBodyAwake();
	bool K2_BoxOverlapComponent(const struct FVector& InBoxCentre, const struct FBox& InBox, bool bTraceComplex, bool bShowTrace, bool bPersistentShowTrace, struct FVector* HitLocation, struct FVector* HitNormal, class FName* BoneName, struct FHitResult* OutHit);
	bool K2_LineTraceComponent(const struct FVector& TraceStart, const struct FVector& TraceEnd, bool bTraceComplex, bool bShowTrace, bool bPersistentShowTrace, struct FVector* HitLocation, struct FVector* HitNormal, class FName* BoneName, struct FHitResult* OutHit);
	bool K2_SphereOverlapComponent(const struct FVector& InSphereCentre, float InSphereRadius, bool bTraceComplex, bool bShowTrace, bool bPersistentShowTrace, struct FVector* HitLocation, struct FVector* HitNormal, class FName* BoneName, struct FHitResult* OutHit);
	bool K2_SphereTraceComponent(const struct FVector& TraceStart, const struct FVector& TraceEnd, float SphereRadius, bool bTraceComplex, bool bShowTrace, bool bPersistentShowTrace, struct FVector* HitLocation, struct FVector* HitNormal, class FName* BoneName, struct FHitResult* OutHit);
	void PutRigidBodyToSleep(class FName BoneName);
	void SetAffectDistanceFieldLighting(bool NewAffectDistanceFieldLighting);
	void SetAffectDynamicIndirectLighting(bool bNewAffectDynamicIndirectLighting);
	void SetAffectIndirectLightingWhileHidden(bool bNewAffectIndirectLightingWhileHidden);
	void SetAllMassScale(float InMassScale);
	void SetAllPhysicsAngularVelocityInDegrees(const struct FVector& NewAngVel, bool bAddToCurrent);
	void SetAllPhysicsAngularVelocityInRadians(const struct FVector& NewAngVel, bool bAddToCurrent);
	void SetAllPhysicsLinearVelocity(const struct FVector& NewVel, bool bAddToCurrent);
	void SetAllUseCCD(bool InUseCCD);
	void SetAngularDamping(float InDamping);
	void SetBoundsScale(float NewBoundsScale);
	void SetCastContactShadow(bool bInCastContactShadow);
	void SetCastHiddenShadow(bool NewCastHiddenShadow);
	void SetCastInsetShadow(bool bInCastInsetShadow);
	void SetCastShadow(bool NewCastShadow);
	void SetCenterOfMass(const struct FVector& CenterOfMassOffset, class FName BoneName);
	void SetCollisionEnabled(ECollisionEnabled NewType);
	void SetCollisionObjectType(ECollisionChannel Channel);
	void SetCollisionProfileName(class FName InCollisionProfileName, bool bUpdateOverlaps);
	void SetCollisionResponseToAllChannels(ECollisionResponse NewResponse);
	void SetCollisionResponseToChannel(ECollisionChannel Channel, ECollisionResponse NewResponse);
	void SetConstraintMode(EDOFMode ConstraintMode);
	void SetCullDistance(float NewCullDistance);
	void SetCustomDepthStencilValue(int32 Value);
	void SetCustomDepthStencilWriteMask(ERendererStencilMask WriteMaskBit);
	void SetCustomPrimitiveDataFloat(int32 DataIndex, float Value);
	void SetCustomPrimitiveDataVector2(int32 DataIndex, const struct FVector2D& Value);
	void SetCustomPrimitiveDataVector3(int32 DataIndex, const struct FVector& Value);
	void SetCustomPrimitiveDataVector4(int32 DataIndex, const struct FVector4& Value);
	void SetDefaultCustomPrimitiveDataFloat(int32 DataIndex, float Value);
	void SetDefaultCustomPrimitiveDataVector2(int32 DataIndex, const struct FVector2D& Value);
	void SetDefaultCustomPrimitiveDataVector3(int32 DataIndex, const struct FVector& Value);
	void SetDefaultCustomPrimitiveDataVector4(int32 DataIndex, const struct FVector4& Value);
	void SetEmissiveLightSource(bool NewEmissiveLightSource);
	void SetEnableGravity(bool bGravityEnabled);
	void SetExcludedFromHLODLevel(EHLODLevelExclusion HLODLevel, bool bExcluded);
	void SetExcludeForSpecificHLODLevels(const TArray<int32>& InExcludeForSpecificHLODLevels);
	void SetExcludeFromLightAttachmentGroup(bool bInExcludeFromLightAttachmentGroup);
	void SetGenerateOverlapEvents(bool bInGenerateOverlapEvents);
	void SetHiddenInSceneCapture(bool bValue);
	void SetHoldout(bool bNewHoldout);
	void SetIgnoreBoundsForEditorFocus(bool bIgnore);
	void SetLightAttachmentsAsGroup(bool bInLightAttachmentsAsGroup);
	void SetLightingChannels(bool bChannel0, bool bChannel1, bool bChannel2);
	void SetLinearDamping(float InDamping);
	void SetMassOverrideInKg(class FName BoneName, float MassInKg, bool bOverrideMass);
	void SetMassScale(class FName BoneName, float InMassScale);
	void SetMaterial(int32 ElementIndex, class UMaterialInterface* Material);
	void SetMaterialByName(class FName MaterialSlotName, class UMaterialInterface* Material);
	void SetNotifyRigidBodyCollision(bool bNewNotifyRigidBodyCollision);
	void SetOnlyOwnerSee(bool bNewOnlyOwnerSee);
	void SetOwnerNoSee(bool bNewOwnerNoSee);
	void SetPhysicsAngularVelocityInDegrees(const struct FVector& NewAngVel, bool bAddToCurrent, class FName BoneName);
	void SetPhysicsAngularVelocityInRadians(const struct FVector& NewAngVel, bool bAddToCurrent, class FName BoneName);
	void SetPhysicsLinearVelocity(const struct FVector& NewVel, bool bAddToCurrent, class FName BoneName);
	void SetPhysicsMaxAngularVelocityInDegrees(float NewMaxAngVel, bool bAddToCurrent, class FName BoneName);
	void SetPhysicsMaxAngularVelocityInRadians(float NewMaxAngVel, bool bAddToCurrent, class FName BoneName);
	void SetPhysMaterialOverride(class UPhysicalMaterial* NewPhysMaterial);
	void SetReceivesDecals(bool bNewReceivesDecals);
	void SetRenderCustomDepth(bool bValue);
	void SetRenderInDepthPass(bool bValue);
	void SetRenderInMainPass(bool bValue);
	void SetScalarParameterForCustomPrimitiveData(class FName ParameterName, float Value);
	void SetScalarParameterForDefaultCustomPrimitiveData(class FName ParameterName, float Value);
	void SetSimulatePhysics(bool bSimulate);
	void SetSingleSampleShadowFromStationaryLights(bool bNewSingleSampleShadowFromStationaryLights);
	void SetStaticWhenNotMoveable(bool bInStaticWhenNotMoveable);
	void SetTranslucencySortDistanceOffset(float NewTranslucencySortDistanceOffset);
	void SetTranslucentSortPriority(int32 NewTranslucentSortPriority);
	void SetUseCCD(bool InUseCCD, class FName BoneName);
	void SetVectorParameterForCustomPrimitiveData(class FName ParameterName, const struct FVector4& Value);
	void SetVectorParameterForDefaultCustomPrimitiveData(class FName ParameterName, const struct FVector4& Value);
	void SetVisibleInRayTracing(bool bNewVisibleInRayTracing);
	void SetVisibleInSceneCaptureOnly(bool bValue);
	void SetWalkableSlopeOverride(const struct FWalkableSlopeOverride& NewOverride);
	void WakeAllRigidBodies();
	void WakeRigidBody(class FName BoneName);

	bool CanCharacterStepUp(class APawn* Pawn) const;
	float GetAngularDamping() const;
	struct FBodyInstanceAsyncPhysicsTickHandle GetBodyInstanceAsyncPhysicsTickHandle(class FName BoneName, bool bGetWelded, int32 Index_0) const;
	struct FVector GetCenterOfMass(class FName BoneName) const;
	float GetClosestPointOnCollision(const struct FVector& Point, struct FVector* OutPointOnBody, class FName BoneName) const;
	ECollisionEnabled GetCollisionEnabled() const;
	ECollisionChannel GetCollisionObjectType() const;
	class FName GetCollisionProfileName() const;
	ECollisionResponse GetCollisionResponseToChannel(ECollisionChannel Channel) const;
	int32 GetCustomPrimitiveDataIndexForScalarParameter(class FName ParameterName) const;
	int32 GetCustomPrimitiveDataIndexForVectorParameter(class FName ParameterName) const;
	TArray<int32> GetExcludeForSpecificHLODLevels() const;
	bool GetGenerateOverlapEvents() const;
	bool GetIgnoreBoundsForEditorFocus() const;
	struct FVector GetInertiaTensor(class FName BoneName) const;
	float GetLinearDamping() const;
	float GetMass() const;
	float GetMassScale(class FName BoneName) const;
	class UMaterialInterface* GetMaterial(int32 ElementIndex) const;
	class UMaterialInterface* GetMaterialFromCollisionFaceIndex(int32 FaceIndex, int32* SectionIndex) const;
	int32 GetNumMaterials() const;
	void GetOverlappingActors(TArray<class AActor*>* OverlappingActors, TSubclassOf<class AActor> ClassFilter) const;
	void GetOverlappingComponents(TArray<class UPrimitiveComponent*>* OutOverlappingComponents) const;
	struct FVector GetPhysicsAngularVelocityInDegrees(class FName BoneName) const;
	struct FVector GetPhysicsAngularVelocityInRadians(class FName BoneName) const;
	bool GetStaticWhenNotMoveable() const;
	const struct FWalkableSlopeOverride GetWalkableSlopeOverride() const;
	bool IsExcludedFromHLODLevel(EHLODLevelExclusion HLODLevel) const;
	bool IsGravityEnabled() const;
	bool IsOverlappingActor(const class AActor* Other) const;
	bool IsOverlappingComponent(const class UPrimitiveComponent* OtherComp) const;
	bool K2_IsCollisionEnabled() const;
	bool K2_IsPhysicsCollisionEnabled() const;
	bool K2_IsQueryCollisionEnabled() const;
	struct FVector ScaleByMomentOfInertia(const struct FVector& InputVector, class FName BoneName) const;
	bool WasRecentlyRendered(float Tolerance) const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"PrimitiveComponent">();
	}
	static class UPrimitiveComponent* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPrimitiveComponent>();
	}
};
static_assert(alignof(UPrimitiveComponent) == 0x000010, "Wrong alignment on UPrimitiveComponent");
static_assert(sizeof(UPrimitiveComponent) == 0x000570, "Wrong size on UPrimitiveComponent");
static_assert(offsetof(UPrimitiveComponent, MinDrawDistance) == 0x0002B8, "Member 'UPrimitiveComponent::MinDrawDistance' has a wrong offset!");
static_assert(offsetof(UPrimitiveComponent, LDMaxDrawDistance) == 0x0002BC, "Member 'UPrimitiveComponent::LDMaxDrawDistance' has a wrong offset!");
static_assert(offsetof(UPrimitiveComponent, CachedMaxDrawDistance) == 0x0002C0, "Member 'UPrimitiveComponent::CachedMaxDrawDistance' has a wrong offset!");
static_assert(offsetof(UPrimitiveComponent, DepthPriorityGroup) == 0x0002C4, "Member 'UPrimitiveComponent::DepthPriorityGroup' has a wrong offset!");
static_assert(offsetof(UPrimitiveComponent, ViewOwnerDepthPriorityGroup) == 0x0002C5, "Member 'UPrimitiveComponent::ViewOwnerDepthPriorityGroup' has a wrong offset!");
static_assert(offsetof(UPrimitiveComponent, IndirectLightingCacheQuality) == 0x0002C6, "Member 'UPrimitiveComponent::IndirectLightingCacheQuality' has a wrong offset!");
static_assert(offsetof(UPrimitiveComponent, LightmapType) == 0x0002C7, "Member 'UPrimitiveComponent::LightmapType' has a wrong offset!");
static_assert(offsetof(UPrimitiveComponent, HLODBatchingPolicy) == 0x0002C8, "Member 'UPrimitiveComponent::HLODBatchingPolicy' has a wrong offset!");
static_assert(offsetof(UPrimitiveComponent, ShadowCacheInvalidationBehavior) == 0x0002CE, "Member 'UPrimitiveComponent::ShadowCacheInvalidationBehavior' has a wrong offset!");
static_assert(offsetof(UPrimitiveComponent, bHasCustomNavigableGeometry) == 0x0002F1, "Member 'UPrimitiveComponent::bHasCustomNavigableGeometry' has a wrong offset!");
static_assert(offsetof(UPrimitiveComponent, CanCharacterStepUpOn) == 0x0002F3, "Member 'UPrimitiveComponent::CanCharacterStepUpOn' has a wrong offset!");
static_assert(offsetof(UPrimitiveComponent, LightingChannels) == 0x0002F4, "Member 'UPrimitiveComponent::LightingChannels' has a wrong offset!");
static_assert(offsetof(UPrimitiveComponent, RayTracingGroupId) == 0x0002F8, "Member 'UPrimitiveComponent::RayTracingGroupId' has a wrong offset!");
static_assert(offsetof(UPrimitiveComponent, VisibilityId) == 0x0002FC, "Member 'UPrimitiveComponent::VisibilityId' has a wrong offset!");
static_assert(offsetof(UPrimitiveComponent, CustomDepthStencilValue) == 0x000300, "Member 'UPrimitiveComponent::CustomDepthStencilValue' has a wrong offset!");
static_assert(offsetof(UPrimitiveComponent, CustomPrimitiveData) == 0x000308, "Member 'UPrimitiveComponent::CustomPrimitiveData' has a wrong offset!");
static_assert(offsetof(UPrimitiveComponent, CustomPrimitiveDataInternal) == 0x000318, "Member 'UPrimitiveComponent::CustomPrimitiveDataInternal' has a wrong offset!");
static_assert(offsetof(UPrimitiveComponent, TranslucencySortPriority) == 0x000330, "Member 'UPrimitiveComponent::TranslucencySortPriority' has a wrong offset!");
static_assert(offsetof(UPrimitiveComponent, TranslucencySortDistanceOffset) == 0x000334, "Member 'UPrimitiveComponent::TranslucencySortDistanceOffset' has a wrong offset!");
static_assert(offsetof(UPrimitiveComponent, RuntimeVirtualTextures) == 0x000338, "Member 'UPrimitiveComponent::RuntimeVirtualTextures' has a wrong offset!");
static_assert(offsetof(UPrimitiveComponent, VirtualTextureLodBias) == 0x000348, "Member 'UPrimitiveComponent::VirtualTextureLodBias' has a wrong offset!");
static_assert(offsetof(UPrimitiveComponent, VirtualTextureCullMips) == 0x000349, "Member 'UPrimitiveComponent::VirtualTextureCullMips' has a wrong offset!");
static_assert(offsetof(UPrimitiveComponent, VirtualTextureMinCoverage) == 0x00034A, "Member 'UPrimitiveComponent::VirtualTextureMinCoverage' has a wrong offset!");
static_assert(offsetof(UPrimitiveComponent, VirtualTextureRenderPassType) == 0x00034B, "Member 'UPrimitiveComponent::VirtualTextureRenderPassType' has a wrong offset!");
static_assert(offsetof(UPrimitiveComponent, BoundsScale) == 0x00035C, "Member 'UPrimitiveComponent::BoundsScale' has a wrong offset!");
static_assert(offsetof(UPrimitiveComponent, MoveIgnoreActors) == 0x000370, "Member 'UPrimitiveComponent::MoveIgnoreActors' has a wrong offset!");
static_assert(offsetof(UPrimitiveComponent, MoveIgnoreComponents) == 0x000380, "Member 'UPrimitiveComponent::MoveIgnoreComponents' has a wrong offset!");
static_assert(offsetof(UPrimitiveComponent, BodyInstance) == 0x0003A0, "Member 'UPrimitiveComponent::BodyInstance' has a wrong offset!");
static_assert(offsetof(UPrimitiveComponent, OnComponentHit) == 0x000530, "Member 'UPrimitiveComponent::OnComponentHit' has a wrong offset!");
static_assert(offsetof(UPrimitiveComponent, OnComponentBeginOverlap) == 0x000531, "Member 'UPrimitiveComponent::OnComponentBeginOverlap' has a wrong offset!");
static_assert(offsetof(UPrimitiveComponent, OnComponentEndOverlap) == 0x000532, "Member 'UPrimitiveComponent::OnComponentEndOverlap' has a wrong offset!");
static_assert(offsetof(UPrimitiveComponent, OnComponentWake) == 0x000533, "Member 'UPrimitiveComponent::OnComponentWake' has a wrong offset!");
static_assert(offsetof(UPrimitiveComponent, OnComponentSleep) == 0x000534, "Member 'UPrimitiveComponent::OnComponentSleep' has a wrong offset!");
static_assert(offsetof(UPrimitiveComponent, OnComponentPhysicsStateChanged) == 0x000536, "Member 'UPrimitiveComponent::OnComponentPhysicsStateChanged' has a wrong offset!");
static_assert(offsetof(UPrimitiveComponent, OnBeginCursorOver) == 0x000537, "Member 'UPrimitiveComponent::OnBeginCursorOver' has a wrong offset!");
static_assert(offsetof(UPrimitiveComponent, OnEndCursorOver) == 0x000538, "Member 'UPrimitiveComponent::OnEndCursorOver' has a wrong offset!");
static_assert(offsetof(UPrimitiveComponent, OnClicked) == 0x000539, "Member 'UPrimitiveComponent::OnClicked' has a wrong offset!");
static_assert(offsetof(UPrimitiveComponent, OnReleased) == 0x00053A, "Member 'UPrimitiveComponent::OnReleased' has a wrong offset!");
static_assert(offsetof(UPrimitiveComponent, OnInputTouchBegin) == 0x00053B, "Member 'UPrimitiveComponent::OnInputTouchBegin' has a wrong offset!");
static_assert(offsetof(UPrimitiveComponent, OnInputTouchEnd) == 0x00053C, "Member 'UPrimitiveComponent::OnInputTouchEnd' has a wrong offset!");
static_assert(offsetof(UPrimitiveComponent, OnInputTouchEnter) == 0x00053D, "Member 'UPrimitiveComponent::OnInputTouchEnter' has a wrong offset!");
static_assert(offsetof(UPrimitiveComponent, OnInputTouchLeave) == 0x00053E, "Member 'UPrimitiveComponent::OnInputTouchLeave' has a wrong offset!");
static_assert(offsetof(UPrimitiveComponent, RayTracingGroupCullingPriority) == 0x00053F, "Member 'UPrimitiveComponent::RayTracingGroupCullingPriority' has a wrong offset!");
static_assert(offsetof(UPrimitiveComponent, CustomDepthStencilWriteMask) == 0x000540, "Member 'UPrimitiveComponent::CustomDepthStencilWriteMask' has a wrong offset!");
static_assert(offsetof(UPrimitiveComponent, ExcludeFromHLODLevels) == 0x000560, "Member 'UPrimitiveComponent::ExcludeFromHLODLevels' has a wrong offset!");
static_assert(offsetof(UPrimitiveComponent, LODParentPrimitive) == 0x000568, "Member 'UPrimitiveComponent::LODParentPrimitive' has a wrong offset!");

// Class Engine.MeshComponent
// 0x0040 (0x05B0 - 0x0570)
#pragma pack(push, 0x1)
class alignas(0x10) UMeshComponent : public UPrimitiveComponent
{
public:
	TArray<class UMaterialInterface*>             OverrideMaterials;                                 // 0x0570(0x0010)(Edit, ZeroConstructor, AdvancedDisplay, UObjectWrapper, NativeAccessSpecifierPublic)
	class UMaterialInterface*                     OverlayMaterial;                                   // 0x0580(0x0008)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, NoDestructor, AdvancedDisplay, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         OverlayMaterialMaxDrawDistance;                    // 0x0588(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_58C[0x14];                                     // 0x058C(0x0014)(Fixing Size After Last Property [ Dumper-7 ])
	uint8                                         bEnableMaterialParameterCaching : 1;               // 0x05A0(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, AdvancedDisplay, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
	uint8                                         Pad_5A1[0x7];                                      // 0x05A1(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void PrestreamTextures(float Seconds, bool bPrioritizeCharacterTextures, int32 CinematicTextureGroups);
	void SetOverlayMaterial(class UMaterialInterface* NewOverlayMaterial);
	void SetOverlayMaterialMaxDrawDistance(float InMaxDrawDistance);
	void SetScalarParameterValueOnMaterials(const class FName ParameterName, const float ParameterValue);
	void SetVectorParameterValueOnMaterials(const class FName ParameterName, const struct FVector& ParameterValue);

	int32 GetMaterialIndex(class FName MaterialSlotName) const;
	TArray<class UMaterialInterface*> GetMaterials() const;
	TArray<class FName> GetMaterialSlotNames() const;
	class UMaterialInterface* GetOverlayMaterial() const;
	float GetOverlayMaterialMaxDrawDistance() const;
	bool IsMaterialSlotNameValid(class FName MaterialSlotName) const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MeshComponent">();
	}
	static class UMeshComponent* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMeshComponent>();
	}
};
#pragma pack(pop)
static_assert(alignof(UMeshComponent) == 0x000010, "Wrong alignment on UMeshComponent");
static_assert(sizeof(UMeshComponent) == 0x0005B0, "Wrong size on UMeshComponent");
static_assert(offsetof(UMeshComponent, OverrideMaterials) == 0x000570, "Member 'UMeshComponent::OverrideMaterials' has a wrong offset!");
static_assert(offsetof(UMeshComponent, OverlayMaterial) == 0x000580, "Member 'UMeshComponent::OverlayMaterial' has a wrong offset!");
static_assert(offsetof(UMeshComponent, OverlayMaterialMaxDrawDistance) == 0x000588, "Member 'UMeshComponent::OverlayMaterialMaxDrawDistance' has a wrong offset!");

// Class Engine.ParticleModule
// 0x0008 (0x0030 - 0x0028)
class UParticleModule : public UObject
{
public:
	uint8                                         bSpawnModule : 1;                                  // 0x0028(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bUpdateModule : 1;                                 // 0x0028(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bFinalUpdateModule : 1;                            // 0x0028(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bUpdateForGPUEmitter : 1;                          // 0x0028(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bCurvesAsColor : 1;                                // 0x0028(0x0001)(BitIndex: 0x04, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         b3DDrawMode : 1;                                   // 0x0028(0x0001)(BitIndex: 0x05, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bSupported3DDrawMode : 1;                          // 0x0028(0x0001)(BitIndex: 0x06, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bEnabled : 1;                                      // 0x0028(0x0001)(BitIndex: 0x07, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bEditable : 1;                                     // 0x0029(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         LODDuplicate : 1;                                  // 0x0029(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bSupportsRandomSeed : 1;                           // 0x0029(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bRequiresLoopingNotification : 1;                  // 0x0029(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         LODValidity;                                       // 0x002A(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_2B[0x5];                                       // 0x002B(0x0005)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ParticleModule">();
	}
	static class UParticleModule* GetDefaultObj()
	{
		return GetDefaultObjImpl<UParticleModule>();
	}
};
static_assert(alignof(UParticleModule) == 0x000008, "Wrong alignment on UParticleModule");
static_assert(sizeof(UParticleModule) == 0x000030, "Wrong size on UParticleModule");
static_assert(offsetof(UParticleModule, LODValidity) == 0x00002A, "Member 'UParticleModule::LODValidity' has a wrong offset!");

// Class Engine.ParticleModuleLightBase
// 0x0000 (0x0030 - 0x0030)
class UParticleModuleLightBase : public UParticleModule
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ParticleModuleLightBase">();
	}
	static class UParticleModuleLightBase* GetDefaultObj()
	{
		return GetDefaultObjImpl<UParticleModuleLightBase>();
	}
};
static_assert(alignof(UParticleModuleLightBase) == 0x000008, "Wrong alignment on UParticleModuleLightBase");
static_assert(sizeof(UParticleModuleLightBase) == 0x000030, "Wrong size on UParticleModuleLightBase");

// Class Engine.ParticleModuleLight
// 0x0110 (0x0140 - 0x0030)
class UParticleModuleLight : public UParticleModuleLightBase
{
public:
	bool                                          bUseInverseSquaredFalloff;                         // 0x0030(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bAffectsTranslucency;                              // 0x0031(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_32[0x2];                                       // 0x0032(0x0002)(Fixing Size After Last Property [ Dumper-7 ])
	uint8                                         bOverrideInverseExposureBlend : 1;                 // 0x0034(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_35[0x3];                                       // 0x0035(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	bool                                          bPreviewLightRadius;                               // 0x0038(0x0001)(Edit, ZeroConstructor, Transient, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_39[0x3];                                       // 0x0039(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         SpawnFraction;                                     // 0x003C(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FRawDistributionVector                 ColorScaleOverLife;                                // 0x0040(0x0060)(Edit, ContainsInstancedReference, NativeAccessSpecifierPublic)
	struct FRawDistributionFloat                  BrightnessOverLife;                                // 0x00A0(0x0030)(Edit, ContainsInstancedReference, NativeAccessSpecifierPublic)
	struct FRawDistributionFloat                  RadiusScale;                                       // 0x00D0(0x0030)(Edit, ContainsInstancedReference, NativeAccessSpecifierPublic)
	struct FRawDistributionFloat                  LightExponent;                                     // 0x0100(0x0030)(Edit, ContainsInstancedReference, NativeAccessSpecifierPublic)
	float                                         InverseExposureBlend;                              // 0x0130(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FLightingChannels                      LightingChannels;                                  // 0x0134(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, AdvancedDisplay, NativeAccessSpecifierPublic)
	uint8                                         Pad_135[0x3];                                      // 0x0135(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         VolumetricScatteringIntensity;                     // 0x0138(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bHighQualityLights;                                // 0x013C(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bShadowCastingLights;                              // 0x013D(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_13E[0x2];                                      // 0x013E(0x0002)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ParticleModuleLight">();
	}
	static class UParticleModuleLight* GetDefaultObj()
	{
		return GetDefaultObjImpl<UParticleModuleLight>();
	}
};
static_assert(alignof(UParticleModuleLight) == 0x000008, "Wrong alignment on UParticleModuleLight");
static_assert(sizeof(UParticleModuleLight) == 0x000140, "Wrong size on UParticleModuleLight");
static_assert(offsetof(UParticleModuleLight, bUseInverseSquaredFalloff) == 0x000030, "Member 'UParticleModuleLight::bUseInverseSquaredFalloff' has a wrong offset!");
static_assert(offsetof(UParticleModuleLight, bAffectsTranslucency) == 0x000031, "Member 'UParticleModuleLight::bAffectsTranslucency' has a wrong offset!");
static_assert(offsetof(UParticleModuleLight, bPreviewLightRadius) == 0x000038, "Member 'UParticleModuleLight::bPreviewLightRadius' has a wrong offset!");
static_assert(offsetof(UParticleModuleLight, SpawnFraction) == 0x00003C, "Member 'UParticleModuleLight::SpawnFraction' has a wrong offset!");
static_assert(offsetof(UParticleModuleLight, ColorScaleOverLife) == 0x000040, "Member 'UParticleModuleLight::ColorScaleOverLife' has a wrong offset!");
static_assert(offsetof(UParticleModuleLight, BrightnessOverLife) == 0x0000A0, "Member 'UParticleModuleLight::BrightnessOverLife' has a wrong offset!");
static_assert(offsetof(UParticleModuleLight, RadiusScale) == 0x0000D0, "Member 'UParticleModuleLight::RadiusScale' has a wrong offset!");
static_assert(offsetof(UParticleModuleLight, LightExponent) == 0x000100, "Member 'UParticleModuleLight::LightExponent' has a wrong offset!");
static_assert(offsetof(UParticleModuleLight, InverseExposureBlend) == 0x000130, "Member 'UParticleModuleLight::InverseExposureBlend' has a wrong offset!");
static_assert(offsetof(UParticleModuleLight, LightingChannels) == 0x000134, "Member 'UParticleModuleLight::LightingChannels' has a wrong offset!");
static_assert(offsetof(UParticleModuleLight, VolumetricScatteringIntensity) == 0x000138, "Member 'UParticleModuleLight::VolumetricScatteringIntensity' has a wrong offset!");
static_assert(offsetof(UParticleModuleLight, bHighQualityLights) == 0x00013C, "Member 'UParticleModuleLight::bHighQualityLights' has a wrong offset!");
static_assert(offsetof(UParticleModuleLight, bShadowCastingLights) == 0x00013D, "Member 'UParticleModuleLight::bShadowCastingLights' has a wrong offset!");

// Class Engine.ParticleModuleLight_Seeded
// 0x0020 (0x0160 - 0x0140)
class UParticleModuleLight_Seeded final : public UParticleModuleLight
{
public:
	struct FParticleRandomSeedInfo                RandomSeedInfo;                                    // 0x0140(0x0020)(Edit, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ParticleModuleLight_Seeded">();
	}
	static class UParticleModuleLight_Seeded* GetDefaultObj()
	{
		return GetDefaultObjImpl<UParticleModuleLight_Seeded>();
	}
};
static_assert(alignof(UParticleModuleLight_Seeded) == 0x000008, "Wrong alignment on UParticleModuleLight_Seeded");
static_assert(sizeof(UParticleModuleLight_Seeded) == 0x000160, "Wrong size on UParticleModuleLight_Seeded");
static_assert(offsetof(UParticleModuleLight_Seeded, RandomSeedInfo) == 0x000140, "Member 'UParticleModuleLight_Seeded::RandomSeedInfo' has a wrong offset!");

// Class Engine.MaterialExpressionCustomOutput
// 0x0000 (0x00B0 - 0x00B0)
class UMaterialExpressionCustomOutput : public UMaterialExpression
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionCustomOutput">();
	}
	static class UMaterialExpressionCustomOutput* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionCustomOutput>();
	}
};
static_assert(alignof(UMaterialExpressionCustomOutput) == 0x000008, "Wrong alignment on UMaterialExpressionCustomOutput");
static_assert(sizeof(UMaterialExpressionCustomOutput) == 0x0000B0, "Wrong size on UMaterialExpressionCustomOutput");

// Class Engine.MaterialExpressionVolumetricCloudEmptySpaceSkippingOutput
// 0x0028 (0x00D8 - 0x00B0)
class UMaterialExpressionVolumetricCloudEmptySpaceSkippingOutput final : public UMaterialExpressionCustomOutput
{
public:
	struct FExpressionInput                       ContainsMatter;                                    // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionVolumetricCloudEmptySpaceSkippingOutput">();
	}
	static class UMaterialExpressionVolumetricCloudEmptySpaceSkippingOutput* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionVolumetricCloudEmptySpaceSkippingOutput>();
	}
};
static_assert(alignof(UMaterialExpressionVolumetricCloudEmptySpaceSkippingOutput) == 0x000008, "Wrong alignment on UMaterialExpressionVolumetricCloudEmptySpaceSkippingOutput");
static_assert(sizeof(UMaterialExpressionVolumetricCloudEmptySpaceSkippingOutput) == 0x0000D8, "Wrong size on UMaterialExpressionVolumetricCloudEmptySpaceSkippingOutput");
static_assert(offsetof(UMaterialExpressionVolumetricCloudEmptySpaceSkippingOutput, ContainsMatter) == 0x0000B0, "Member 'UMaterialExpressionVolumetricCloudEmptySpaceSkippingOutput::ContainsMatter' has a wrong offset!");

// Class Engine.ParticleModuleTrailBase
// 0x0000 (0x0030 - 0x0030)
class UParticleModuleTrailBase : public UParticleModule
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ParticleModuleTrailBase">();
	}
	static class UParticleModuleTrailBase* GetDefaultObj()
	{
		return GetDefaultObjImpl<UParticleModuleTrailBase>();
	}
};
static_assert(alignof(UParticleModuleTrailBase) == 0x000008, "Wrong alignment on UParticleModuleTrailBase");
static_assert(sizeof(UParticleModuleTrailBase) == 0x000030, "Wrong size on UParticleModuleTrailBase");

// Class Engine.ParticleModuleTrailSource
// 0x0060 (0x0090 - 0x0030)
class UParticleModuleTrailSource final : public UParticleModuleTrailBase
{
public:
	ETrail2SourceMethod                           SourceMethod;                                      // 0x0030(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_31[0x3];                                       // 0x0031(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	class FName                                   SourceName;                                        // 0x0034(0x0008)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_3C[0x4];                                       // 0x003C(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	struct FRawDistributionFloat                  SourceStrength;                                    // 0x0040(0x0030)(Edit, ContainsInstancedReference, NativeAccessSpecifierPublic)
	uint8                                         bLockSourceStength : 1;                            // 0x0070(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_71[0x3];                                       // 0x0071(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	int32                                         SourceOffsetCount;                                 // 0x0074(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TArray<struct FVector>                        SourceOffsetDefaults;                              // 0x0078(0x0010)(Edit, EditFixedSize, ZeroConstructor, NativeAccessSpecifierPublic)
	EParticleSourceSelectionMethod                SelectionMethod;                                   // 0x0088(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_89[0x3];                                       // 0x0089(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	uint8                                         bInheritRotation : 1;                              // 0x008C(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_8D[0x3];                                       // 0x008D(0x0003)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ParticleModuleTrailSource">();
	}
	static class UParticleModuleTrailSource* GetDefaultObj()
	{
		return GetDefaultObjImpl<UParticleModuleTrailSource>();
	}
};
static_assert(alignof(UParticleModuleTrailSource) == 0x000008, "Wrong alignment on UParticleModuleTrailSource");
static_assert(sizeof(UParticleModuleTrailSource) == 0x000090, "Wrong size on UParticleModuleTrailSource");
static_assert(offsetof(UParticleModuleTrailSource, SourceMethod) == 0x000030, "Member 'UParticleModuleTrailSource::SourceMethod' has a wrong offset!");
static_assert(offsetof(UParticleModuleTrailSource, SourceName) == 0x000034, "Member 'UParticleModuleTrailSource::SourceName' has a wrong offset!");
static_assert(offsetof(UParticleModuleTrailSource, SourceStrength) == 0x000040, "Member 'UParticleModuleTrailSource::SourceStrength' has a wrong offset!");
static_assert(offsetof(UParticleModuleTrailSource, SourceOffsetCount) == 0x000074, "Member 'UParticleModuleTrailSource::SourceOffsetCount' has a wrong offset!");
static_assert(offsetof(UParticleModuleTrailSource, SourceOffsetDefaults) == 0x000078, "Member 'UParticleModuleTrailSource::SourceOffsetDefaults' has a wrong offset!");
static_assert(offsetof(UParticleModuleTrailSource, SelectionMethod) == 0x000088, "Member 'UParticleModuleTrailSource::SelectionMethod' has a wrong offset!");

// Class Engine.Channel
// 0x0040 (0x0068 - 0x0028)
class UChannel : public UObject
{
public:
	class UNetConnection*                         Connection;                                        // 0x0028(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_30[0x38];                                      // 0x0030(0x0038)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"Channel">();
	}
	static class UChannel* GetDefaultObj()
	{
		return GetDefaultObjImpl<UChannel>();
	}
};
static_assert(alignof(UChannel) == 0x000008, "Wrong alignment on UChannel");
static_assert(sizeof(UChannel) == 0x000068, "Wrong size on UChannel");
static_assert(offsetof(UChannel, Connection) == 0x000028, "Member 'UChannel::Connection' has a wrong offset!");

// Class Engine.ActorChannel
// 0x0230 (0x0298 - 0x0068)
class UActorChannel final : public UChannel
{
public:
	class AActor*                                 Actor;                                             // 0x0068(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_70[0xF0];                                      // 0x0070(0x00F0)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<class UObject*>                        CreateSubObjects;                                  // 0x0160(0x0010)(ZeroConstructor, UObjectWrapper, NativeAccessSpecifierPublic)
	uint8                                         Pad_170[0x128];                                    // 0x0170(0x0128)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ActorChannel">();
	}
	static class UActorChannel* GetDefaultObj()
	{
		return GetDefaultObjImpl<UActorChannel>();
	}
};
static_assert(alignof(UActorChannel) == 0x000008, "Wrong alignment on UActorChannel");
static_assert(sizeof(UActorChannel) == 0x000298, "Wrong size on UActorChannel");
static_assert(offsetof(UActorChannel, Actor) == 0x000068, "Member 'UActorChannel::Actor' has a wrong offset!");
static_assert(offsetof(UActorChannel, CreateSubObjects) == 0x000160, "Member 'UActorChannel::CreateSubObjects' has a wrong offset!");

// Class Engine.MaterialExpressionStrataBSDF
// 0x0000 (0x00B0 - 0x00B0)
class UMaterialExpressionStrataBSDF : public UMaterialExpression
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionStrataBSDF">();
	}
	static class UMaterialExpressionStrataBSDF* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionStrataBSDF>();
	}
};
static_assert(alignof(UMaterialExpressionStrataBSDF) == 0x000008, "Wrong alignment on UMaterialExpressionStrataBSDF");
static_assert(sizeof(UMaterialExpressionStrataBSDF) == 0x0000B0, "Wrong size on UMaterialExpressionStrataBSDF");

// Class Engine.MaterialExpressionStrataPostProcess
// 0x0050 (0x0100 - 0x00B0)
class UMaterialExpressionStrataPostProcess final : public UMaterialExpressionStrataBSDF
{
public:
	struct FExpressionInput                       Color;                                             // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       Opacity;                                           // 0x00D8(0x0028)(NoDestructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionStrataPostProcess">();
	}
	static class UMaterialExpressionStrataPostProcess* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionStrataPostProcess>();
	}
};
static_assert(alignof(UMaterialExpressionStrataPostProcess) == 0x000008, "Wrong alignment on UMaterialExpressionStrataPostProcess");
static_assert(sizeof(UMaterialExpressionStrataPostProcess) == 0x000100, "Wrong size on UMaterialExpressionStrataPostProcess");
static_assert(offsetof(UMaterialExpressionStrataPostProcess, Color) == 0x0000B0, "Member 'UMaterialExpressionStrataPostProcess::Color' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionStrataPostProcess, Opacity) == 0x0000D8, "Member 'UMaterialExpressionStrataPostProcess::Opacity' has a wrong offset!");

// Class Engine.Material
// 0x0168 (0x0218 - 0x00B0)
class UMaterial final : public UMaterialInterface
{
public:
	class UPhysicalMaterial*                      PhysMaterial;                                      // 0x00B0(0x0008)(Edit, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UPhysicalMaterialMask*                  PhysMaterialMask;                                  // 0x00B8(0x0008)(Edit, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UPhysicalMaterial*                      PhysicalMaterialMap[0x8];                          // 0x00C0(0x0008)(Edit, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TArray<class UPhysicalMaterial*>              RenderTracePhysicalMaterialOutputs;                // 0x0100(0x0010)(ZeroConstructor, UObjectWrapper, NativeAccessSpecifierPublic)
	EMaterialDomain                               MaterialDomain;                                    // 0x0110(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, AssetRegistrySearchable, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EBlendMode                                    BlendMode;                                         // 0x0111(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, AssetRegistrySearchable, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EDecalBlendMode                               DecalBlendMode;                                    // 0x0112(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EMaterialDecalResponse                        MaterialDecalResponse;                             // 0x0113(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, AssetRegistrySearchable, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_114[0x4];                                      // 0x0114(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	struct FMaterialOverrideNanite                NaniteOverrideMaterial;                            // 0x0118(0x0038)(Edit, NativeAccessSpecifierPublic)
	struct FDisplacementScaling                   DisplacementScaling;                               // 0x0150(0x0008)(Edit, BlueprintVisible, NoDestructor, NativeAccessSpecifierPublic)
	EMaterialShadingModel                         ShadingModel;                                      // 0x0158(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, AssetRegistrySearchable, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         bCastDynamicShadowAsMasked : 1;                    // 0x0159(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	struct FMaterialShadingModelField             ShadingModels;                                     // 0x015A(0x0002)(NoDestructor, AssetRegistrySearchable, NativeAccessSpecifierPrivate)
	float                                         OpacityMaskClipValue;                              // 0x015C(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bEnableSeparateTranslucency : 1;                   // 0x0160(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Deprecated, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate))
	uint8                                         bEnableResponsiveAA : 1;                           // 0x0160(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bScreenSpaceReflections : 1;                       // 0x0160(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bContactShadows : 1;                               // 0x0160(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         TwoSided : 1;                                      // 0x0160(0x0001)(BitIndex: 0x04, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bIsThinSurface : 1;                                // 0x0160(0x0001)(BitIndex: 0x05, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         DitheredLODTransition : 1;                         // 0x0160(0x0001)(BitIndex: 0x06, PropSize: 0x0001 (Edit, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         DitherOpacityMask : 1;                             // 0x0160(0x0001)(BitIndex: 0x07, PropSize: 0x0001 (Edit, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bAllowNegativeEmissiveColor : 1;                   // 0x0161(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	EMaterialTranslucencyPass                     TranslucencyPass;                                  // 0x0162(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	ETranslucencyLightingMode                     TranslucencyLightingMode;                          // 0x0163(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, AssetRegistrySearchable, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bEnableMobileSeparateTranslucency : 1;             // 0x0164(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_165[0x3];                                      // 0x0165(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	int32                                         NumCustomizedUVs;                                  // 0x0168(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         TranslucencyDirectionalLightingIntensity;          // 0x016C(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         TranslucentShadowDensityScale;                     // 0x0170(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         TranslucentSelfShadowDensityScale;                 // 0x0174(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         TranslucentSelfShadowSecondDensityScale;           // 0x0178(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         TranslucentSelfShadowSecondOpacity;                // 0x017C(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         TranslucentBackscatteringExponent;                 // 0x0180(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FLinearColor                           TranslucentMultipleScatteringExtinction;           // 0x0184(0x0010)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         TranslucentShadowStartOffset;                      // 0x0194(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bDisableDepthTest : 1;                             // 0x0198(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bWriteOnlyAlpha : 1;                               // 0x0198(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bGenerateSphericalParticleNormals : 1;             // 0x0198(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Edit, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bTangentSpaceNormal : 1;                           // 0x0198(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (Edit, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bUseEmissiveForDynamicAreaLighting : 1;            // 0x0198(0x0001)(BitIndex: 0x04, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bUsedAsSpecialEngineMaterial : 1;                  // 0x0198(0x0001)(BitIndex: 0x05, PropSize: 0x0001 (DuplicateTransient, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bUsedWithSkeletalMesh : 1;                         // 0x0198(0x0001)(BitIndex: 0x06, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bUsedWithEditorCompositing : 1;                    // 0x0198(0x0001)(BitIndex: 0x07, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bUsedWithParticleSprites : 1;                      // 0x0199(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bUsedWithBeamTrails : 1;                           // 0x0199(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bUsedWithMeshParticles : 1;                        // 0x0199(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bUsedWithNiagaraSprites : 1;                       // 0x0199(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bUsedWithNiagaraRibbons : 1;                       // 0x0199(0x0001)(BitIndex: 0x04, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bUsedWithNiagaraMeshParticles : 1;                 // 0x0199(0x0001)(BitIndex: 0x05, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bUsedWithGeometryCache : 1;                        // 0x0199(0x0001)(BitIndex: 0x06, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bUsedWithStaticLighting : 1;                       // 0x0199(0x0001)(BitIndex: 0x07, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bUsedWithMorphTargets : 1;                         // 0x019A(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bUsedWithSplineMeshes : 1;                         // 0x019A(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bUsedWithInstancedStaticMeshes : 1;                // 0x019A(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bUsedWithGeometryCollections : 1;                  // 0x019A(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bUsesDistortion : 1;                               // 0x019A(0x0001)(BitIndex: 0x04, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bRootNodeOverridesDefaultDistortion : 1;           // 0x019A(0x0001)(BitIndex: 0x05, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bUsedWithClothing : 1;                             // 0x019A(0x0001)(BitIndex: 0x06, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         BitPad_19A_7 : 1;                                  // 0x019A(0x0001)(Fixing Bit-Field Size For New Byte [ Dumper-7 ])
	uint8                                         Pad_19B[0x1];                                      // 0x019B(0x0001)(Fixing Size After Last Property [ Dumper-7 ])
	uint8                                         bUsedWithWater : 1;                                // 0x019C(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bUsedWithHairStrands : 1;                          // 0x019C(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bUsedWithLidarPointCloud : 1;                      // 0x019C(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bUsedWithVirtualHeightfieldMesh : 1;               // 0x019C(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bUsedWithNanite : 1;                               // 0x019C(0x0001)(BitIndex: 0x04, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bUsedWithVolumetricCloud : 1;                      // 0x019C(0x0001)(BitIndex: 0x05, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bUsedWithHeterogeneousVolumes : 1;                 // 0x019C(0x0001)(BitIndex: 0x06, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         BitPad_19C_7 : 1;                                  // 0x019C(0x0001)(Fixing Bit-Field Size For New Byte [ Dumper-7 ])
	uint8                                         Pad_19D[0x3];                                      // 0x019D(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	uint8                                         bUsedWithUI : 1;                                   // 0x01A0(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Deprecated, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bAutomaticallySetUsageInEditor : 1;                // 0x01A0(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bFullyRough : 1;                                   // 0x01A0(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bUseFullPrecision : 1;                             // 0x01A0(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (Deprecated, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	EMaterialFloatPrecisionMode                   FloatPrecisionMode;                                // 0x01A1(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bUseLightmapDirectionality : 1;                    // 0x01A2(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bMobileEnableHighQualityBRDF : 1;                  // 0x01A2(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bUseAlphaToCoverage : 1;                           // 0x01A2(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         BitPad_1A2_3 : 5;                                  // 0x01A2(0x0001)(Fixing Bit-Field Size For New Byte [ Dumper-7 ])
	uint8                                         Pad_1A3[0x1];                                      // 0x01A3(0x0001)(Fixing Size After Last Property [ Dumper-7 ])
	uint8                                         bForwardRenderUsePreintegratedGFForSimpleIBL : 1;  // 0x01A4(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         BitPad_1A4_1 : 7;                                  // 0x01A4(0x0001)(Fixing Bit-Field Size For New Byte [ Dumper-7 ])
	uint8                                         Pad_1A5[0x3];                                      // 0x01A5(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	uint8                                         bUseHQForwardReflections : 1;                      // 0x01A8(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bForwardBlendsSkyLightCubemaps : 1;                // 0x01A8(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bUsePlanarForwardReflections : 1;                  // 0x01A8(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bNormalCurvatureToRoughness : 1;                   // 0x01A8(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         AllowTranslucentCustomDepthWrites : 1;             // 0x01A8(0x0001)(BitIndex: 0x04, PropSize: 0x0001 (Edit, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bAllowFrontLayerTranslucency : 1;                  // 0x01A8(0x0001)(BitIndex: 0x05, PropSize: 0x0001 (Edit, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Wireframe : 1;                                     // 0x01A8(0x0001)(BitIndex: 0x06, PropSize: 0x0001 (Edit, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	EMaterialShadingRate                          ShadingRate;                                       // 0x01A9(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bCanMaskedBeAssumedOpaque : 1;                     // 0x01AA(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bIsMasked : 1;                                     // 0x01AA(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Deprecated, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bIsPreviewMaterial : 1;                            // 0x01AA(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Transient, DuplicateTransient, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bIsFunctionPreviewMaterial : 1;                    // 0x01AA(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (Transient, DuplicateTransient, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bUseMaterialAttributes : 1;                        // 0x01AA(0x0001)(BitIndex: 0x04, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bEnableExecWire : 1;                               // 0x01AA(0x0001)(BitIndex: 0x05, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bEnableNewHLSLGenerator : 1;                       // 0x01AA(0x0001)(BitIndex: 0x06, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bCastRayTracedShadows : 1;                         // 0x01AA(0x0001)(BitIndex: 0x07, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bUseTranslucencyVertexFog : 1;                     // 0x01AB(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bApplyCloudFogging : 1;                            // 0x01AB(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bIsSky : 1;                                        // 0x01AB(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Edit, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bComputeFogPerPixel : 1;                           // 0x01AB(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bOutputTranslucentVelocity : 1;                    // 0x01AB(0x0001)(BitIndex: 0x04, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bAllowDevelopmentShaderCompile : 1;                // 0x01AB(0x0001)(BitIndex: 0x05, PropSize: 0x0001 (Transient, DuplicateTransient, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bIsMaterialEditorStatsMaterial : 1;                // 0x01AB(0x0001)(BitIndex: 0x06, PropSize: 0x0001 (Transient, DuplicateTransient, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	EBlendableLocation                            BlendableLocation;                                 // 0x01AC(0x0001)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         BlendableOutputAlpha : 1;                          // 0x01AD(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bEnableStencilTest : 1;                            // 0x01AD(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	EMaterialStencilCompare                       StencilCompare;                                    // 0x01AE(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         StencilRefValue;                                   // 0x01AF(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	ERefractionMode                               RefractionMode;                                    // 0x01B0(0x0001)(ZeroConstructor, Deprecated, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	ERefractionMode                               RefractionMethod;                                  // 0x01B1(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	ERefractionCoverageMode                       RefractionCoverageMode;                            // 0x01B2(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1B3[0x1];                                      // 0x01B3(0x0001)(Fixing Size After Last Property [ Dumper-7 ])
	int32                                         BlendablePriority;                                 // 0x01B4(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bIsBlendable : 1;                                  // 0x01B8(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_1B9[0x3];                                      // 0x01B9(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	uint32                                        UsageFlagWarnings;                                 // 0x01BC(0x0004)(ZeroConstructor, Transient, DuplicateTransient, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1C0[0x4];                                      // 0x01C0(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         RefractionDepthBias;                               // 0x01C4(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         MaxWorldPositionOffsetDisplacement;                // 0x01C8(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bAlwaysEvaluateWorldPositionOffset;                // 0x01CC(0x0001)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1CD[0x7];                                      // 0x01CD(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	struct FGuid                                  StateId;                                           // 0x01D4(0x0010)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1E4[0x34];                                     // 0x01E4(0x0034)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"Material">();
	}
	static class UMaterial* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterial>();
	}
};
static_assert(alignof(UMaterial) == 0x000008, "Wrong alignment on UMaterial");
static_assert(sizeof(UMaterial) == 0x000218, "Wrong size on UMaterial");
static_assert(offsetof(UMaterial, PhysMaterial) == 0x0000B0, "Member 'UMaterial::PhysMaterial' has a wrong offset!");
static_assert(offsetof(UMaterial, PhysMaterialMask) == 0x0000B8, "Member 'UMaterial::PhysMaterialMask' has a wrong offset!");
static_assert(offsetof(UMaterial, PhysicalMaterialMap) == 0x0000C0, "Member 'UMaterial::PhysicalMaterialMap' has a wrong offset!");
static_assert(offsetof(UMaterial, RenderTracePhysicalMaterialOutputs) == 0x000100, "Member 'UMaterial::RenderTracePhysicalMaterialOutputs' has a wrong offset!");
static_assert(offsetof(UMaterial, MaterialDomain) == 0x000110, "Member 'UMaterial::MaterialDomain' has a wrong offset!");
static_assert(offsetof(UMaterial, BlendMode) == 0x000111, "Member 'UMaterial::BlendMode' has a wrong offset!");
static_assert(offsetof(UMaterial, DecalBlendMode) == 0x000112, "Member 'UMaterial::DecalBlendMode' has a wrong offset!");
static_assert(offsetof(UMaterial, MaterialDecalResponse) == 0x000113, "Member 'UMaterial::MaterialDecalResponse' has a wrong offset!");
static_assert(offsetof(UMaterial, NaniteOverrideMaterial) == 0x000118, "Member 'UMaterial::NaniteOverrideMaterial' has a wrong offset!");
static_assert(offsetof(UMaterial, DisplacementScaling) == 0x000150, "Member 'UMaterial::DisplacementScaling' has a wrong offset!");
static_assert(offsetof(UMaterial, ShadingModel) == 0x000158, "Member 'UMaterial::ShadingModel' has a wrong offset!");
static_assert(offsetof(UMaterial, ShadingModels) == 0x00015A, "Member 'UMaterial::ShadingModels' has a wrong offset!");
static_assert(offsetof(UMaterial, OpacityMaskClipValue) == 0x00015C, "Member 'UMaterial::OpacityMaskClipValue' has a wrong offset!");
static_assert(offsetof(UMaterial, TranslucencyPass) == 0x000162, "Member 'UMaterial::TranslucencyPass' has a wrong offset!");
static_assert(offsetof(UMaterial, TranslucencyLightingMode) == 0x000163, "Member 'UMaterial::TranslucencyLightingMode' has a wrong offset!");
static_assert(offsetof(UMaterial, NumCustomizedUVs) == 0x000168, "Member 'UMaterial::NumCustomizedUVs' has a wrong offset!");
static_assert(offsetof(UMaterial, TranslucencyDirectionalLightingIntensity) == 0x00016C, "Member 'UMaterial::TranslucencyDirectionalLightingIntensity' has a wrong offset!");
static_assert(offsetof(UMaterial, TranslucentShadowDensityScale) == 0x000170, "Member 'UMaterial::TranslucentShadowDensityScale' has a wrong offset!");
static_assert(offsetof(UMaterial, TranslucentSelfShadowDensityScale) == 0x000174, "Member 'UMaterial::TranslucentSelfShadowDensityScale' has a wrong offset!");
static_assert(offsetof(UMaterial, TranslucentSelfShadowSecondDensityScale) == 0x000178, "Member 'UMaterial::TranslucentSelfShadowSecondDensityScale' has a wrong offset!");
static_assert(offsetof(UMaterial, TranslucentSelfShadowSecondOpacity) == 0x00017C, "Member 'UMaterial::TranslucentSelfShadowSecondOpacity' has a wrong offset!");
static_assert(offsetof(UMaterial, TranslucentBackscatteringExponent) == 0x000180, "Member 'UMaterial::TranslucentBackscatteringExponent' has a wrong offset!");
static_assert(offsetof(UMaterial, TranslucentMultipleScatteringExtinction) == 0x000184, "Member 'UMaterial::TranslucentMultipleScatteringExtinction' has a wrong offset!");
static_assert(offsetof(UMaterial, TranslucentShadowStartOffset) == 0x000194, "Member 'UMaterial::TranslucentShadowStartOffset' has a wrong offset!");
static_assert(offsetof(UMaterial, FloatPrecisionMode) == 0x0001A1, "Member 'UMaterial::FloatPrecisionMode' has a wrong offset!");
static_assert(offsetof(UMaterial, ShadingRate) == 0x0001A9, "Member 'UMaterial::ShadingRate' has a wrong offset!");
static_assert(offsetof(UMaterial, BlendableLocation) == 0x0001AC, "Member 'UMaterial::BlendableLocation' has a wrong offset!");
static_assert(offsetof(UMaterial, StencilCompare) == 0x0001AE, "Member 'UMaterial::StencilCompare' has a wrong offset!");
static_assert(offsetof(UMaterial, StencilRefValue) == 0x0001AF, "Member 'UMaterial::StencilRefValue' has a wrong offset!");
static_assert(offsetof(UMaterial, RefractionMode) == 0x0001B0, "Member 'UMaterial::RefractionMode' has a wrong offset!");
static_assert(offsetof(UMaterial, RefractionMethod) == 0x0001B1, "Member 'UMaterial::RefractionMethod' has a wrong offset!");
static_assert(offsetof(UMaterial, RefractionCoverageMode) == 0x0001B2, "Member 'UMaterial::RefractionCoverageMode' has a wrong offset!");
static_assert(offsetof(UMaterial, BlendablePriority) == 0x0001B4, "Member 'UMaterial::BlendablePriority' has a wrong offset!");
static_assert(offsetof(UMaterial, UsageFlagWarnings) == 0x0001BC, "Member 'UMaterial::UsageFlagWarnings' has a wrong offset!");
static_assert(offsetof(UMaterial, RefractionDepthBias) == 0x0001C4, "Member 'UMaterial::RefractionDepthBias' has a wrong offset!");
static_assert(offsetof(UMaterial, MaxWorldPositionOffsetDisplacement) == 0x0001C8, "Member 'UMaterial::MaxWorldPositionOffsetDisplacement' has a wrong offset!");
static_assert(offsetof(UMaterial, bAlwaysEvaluateWorldPositionOffset) == 0x0001CC, "Member 'UMaterial::bAlwaysEvaluateWorldPositionOffset' has a wrong offset!");
static_assert(offsetof(UMaterial, StateId) == 0x0001D4, "Member 'UMaterial::StateId' has a wrong offset!");

// Class Engine.MaterialExpressionCloudSampleAttribute
// 0x0000 (0x00B0 - 0x00B0)
class UMaterialExpressionCloudSampleAttribute final : public UMaterialExpression
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionCloudSampleAttribute">();
	}
	static class UMaterialExpressionCloudSampleAttribute* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionCloudSampleAttribute>();
	}
};
static_assert(alignof(UMaterialExpressionCloudSampleAttribute) == 0x000008, "Wrong alignment on UMaterialExpressionCloudSampleAttribute");
static_assert(sizeof(UMaterialExpressionCloudSampleAttribute) == 0x0000B0, "Wrong size on UMaterialExpressionCloudSampleAttribute");

// Class Engine.EdGraphNode
// 0x0070 (0x0098 - 0x0028)
class UEdGraphNode : public UObject
{
public:
	uint8                                         Pad_28[0x10];                                      // 0x0028(0x0010)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<class UEdGraphPin_Deprecated*>         DeprecatedPins;                                    // 0x0038(0x0010)(ZeroConstructor, UObjectWrapper, NativeAccessSpecifierPublic)
	int32                                         NodePosX;                                          // 0x0048(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         NodePosY;                                          // 0x004C(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         NodeWidth;                                         // 0x0050(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         NodeHeight;                                        // 0x0054(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	ENodeAdvancedPins                             AdvancedPinDisplay;                                // 0x0058(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	ENodeEnabledState                             EnabledState;                                      // 0x0059(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_5A[0x1];                                       // 0x005A(0x0001)(Fixing Size After Last Property [ Dumper-7 ])
	uint8                                         BitPad_5B_0 : 1;                                   // 0x005B(0x0001)(Fixing Bit-Field Size Between Bits [ Dumper-7 ])
	uint8                                         bDisplayAsDisabled : 1;                            // 0x005B(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate))
	uint8                                         bUserSetEnabledState : 1;                          // 0x005B(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate))
	uint8                                         bIsIntermediateNode : 1;                           // 0x005B(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate))
	uint8                                         bHasCompilerMessage : 1;                           // 0x005B(0x0001)(BitIndex: 0x04, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_5C[0x4];                                       // 0x005C(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	class FString                                 NodeComment;                                       // 0x0060(0x0010)(ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         ErrorType;                                         // 0x0070(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_74[0x4];                                       // 0x0074(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	class FString                                 ErrorMsg;                                          // 0x0078(0x0010)(ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FGuid                                  NodeGuid;                                          // 0x0088(0x0010)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"EdGraphNode">();
	}
	static class UEdGraphNode* GetDefaultObj()
	{
		return GetDefaultObjImpl<UEdGraphNode>();
	}
};
static_assert(alignof(UEdGraphNode) == 0x000008, "Wrong alignment on UEdGraphNode");
static_assert(sizeof(UEdGraphNode) == 0x000098, "Wrong size on UEdGraphNode");
static_assert(offsetof(UEdGraphNode, DeprecatedPins) == 0x000038, "Member 'UEdGraphNode::DeprecatedPins' has a wrong offset!");
static_assert(offsetof(UEdGraphNode, NodePosX) == 0x000048, "Member 'UEdGraphNode::NodePosX' has a wrong offset!");
static_assert(offsetof(UEdGraphNode, NodePosY) == 0x00004C, "Member 'UEdGraphNode::NodePosY' has a wrong offset!");
static_assert(offsetof(UEdGraphNode, NodeWidth) == 0x000050, "Member 'UEdGraphNode::NodeWidth' has a wrong offset!");
static_assert(offsetof(UEdGraphNode, NodeHeight) == 0x000054, "Member 'UEdGraphNode::NodeHeight' has a wrong offset!");
static_assert(offsetof(UEdGraphNode, AdvancedPinDisplay) == 0x000058, "Member 'UEdGraphNode::AdvancedPinDisplay' has a wrong offset!");
static_assert(offsetof(UEdGraphNode, EnabledState) == 0x000059, "Member 'UEdGraphNode::EnabledState' has a wrong offset!");
static_assert(offsetof(UEdGraphNode, NodeComment) == 0x000060, "Member 'UEdGraphNode::NodeComment' has a wrong offset!");
static_assert(offsetof(UEdGraphNode, ErrorType) == 0x000070, "Member 'UEdGraphNode::ErrorType' has a wrong offset!");
static_assert(offsetof(UEdGraphNode, ErrorMsg) == 0x000078, "Member 'UEdGraphNode::ErrorMsg' has a wrong offset!");
static_assert(offsetof(UEdGraphNode, NodeGuid) == 0x000088, "Member 'UEdGraphNode::NodeGuid' has a wrong offset!");

// Class Engine.NavRelevantInterface
// 0x0000 (0x0000 - 0x0000)
class INavRelevantInterface final
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"NavRelevantInterface">();
	}
	static class INavRelevantInterface* GetDefaultObj()
	{
		return GetDefaultObjImpl<INavRelevantInterface>();
	}

	class UObject* AsUObject()
	{
		return reinterpret_cast<UObject*>(this);
	}
	const class UObject* AsUObject() const
	{
		return reinterpret_cast<const UObject*>(this);
	}
};
static_assert(alignof(INavRelevantInterface) == 0x000001, "Wrong alignment on INavRelevantInterface");
static_assert(sizeof(INavRelevantInterface) == 0x000001, "Wrong size on INavRelevantInterface");

// Class Engine.ModelComponent
// 0x0040 (0x05B0 - 0x0570)
class UModelComponent final : public UPrimitiveComponent
{
public:
	uint8                                         Pad_570[0x18];                                     // 0x0570(0x0018)(Fixing Size After Last Property [ Dumper-7 ])
	class UBodySetup*                             ModelBodySetup;                                    // 0x0588(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_590[0x20];                                     // 0x0590(0x0020)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ModelComponent">();
	}
	static class UModelComponent* GetDefaultObj()
	{
		return GetDefaultObjImpl<UModelComponent>();
	}
};
static_assert(alignof(UModelComponent) == 0x000010, "Wrong alignment on UModelComponent");
static_assert(sizeof(UModelComponent) == 0x0005B0, "Wrong size on UModelComponent");
static_assert(offsetof(UModelComponent, ModelBodySetup) == 0x000588, "Member 'UModelComponent::ModelBodySetup' has a wrong offset!");

// Class Engine.Subsystem
// 0x0008 (0x0030 - 0x0028)
class USubsystem : public UObject
{
public:
	uint8                                         Pad_28[0x8];                                       // 0x0028(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"Subsystem">();
	}
	static class USubsystem* GetDefaultObj()
	{
		return GetDefaultObjImpl<USubsystem>();
	}
};
static_assert(alignof(USubsystem) == 0x000008, "Wrong alignment on USubsystem");
static_assert(sizeof(USubsystem) == 0x000030, "Wrong size on USubsystem");

// Class Engine.WorldSubsystem
// 0x0000 (0x0030 - 0x0030)
class UWorldSubsystem : public USubsystem
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"WorldSubsystem">();
	}
	static class UWorldSubsystem* GetDefaultObj()
	{
		return GetDefaultObjImpl<UWorldSubsystem>();
	}
};
static_assert(alignof(UWorldSubsystem) == 0x000008, "Wrong alignment on UWorldSubsystem");
static_assert(sizeof(UWorldSubsystem) == 0x000030, "Wrong size on UWorldSubsystem");

// Class Engine.SoundNode
// 0x0020 (0x0048 - 0x0028)
class USoundNode : public UObject
{
public:
	TArray<class USoundNode*>                     ChildNodes;                                        // 0x0028(0x0010)(BlueprintVisible, BlueprintReadOnly, ZeroConstructor, UObjectWrapper, NativeAccessSpecifierPublic)
	uint8                                         Pad_38[0x10];                                      // 0x0038(0x0010)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"SoundNode">();
	}
	static class USoundNode* GetDefaultObj()
	{
		return GetDefaultObjImpl<USoundNode>();
	}
};
static_assert(alignof(USoundNode) == 0x000008, "Wrong alignment on USoundNode");
static_assert(sizeof(USoundNode) == 0x000048, "Wrong size on USoundNode");
static_assert(offsetof(USoundNode, ChildNodes) == 0x000028, "Member 'USoundNode::ChildNodes' has a wrong offset!");

// Class Engine.SoundNodeMixer
// 0x0010 (0x0058 - 0x0048)
class USoundNodeMixer final : public USoundNode
{
public:
	TArray<float>                                 InputVolume;                                       // 0x0048(0x0010)(Edit, ExportObject, EditFixedSize, ZeroConstructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"SoundNodeMixer">();
	}
	static class USoundNodeMixer* GetDefaultObj()
	{
		return GetDefaultObjImpl<USoundNodeMixer>();
	}
};
static_assert(alignof(USoundNodeMixer) == 0x000008, "Wrong alignment on USoundNodeMixer");
static_assert(sizeof(USoundNodeMixer) == 0x000058, "Wrong size on USoundNodeMixer");
static_assert(offsetof(USoundNodeMixer, InputVolume) == 0x000048, "Member 'USoundNodeMixer::InputVolume' has a wrong offset!");

// Class Engine.MaterialExpressionStrataWeight
// 0x0050 (0x0100 - 0x00B0)
class UMaterialExpressionStrataWeight final : public UMaterialExpressionStrataBSDF
{
public:
	struct FExpressionInput                       A;                                                 // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       Weight;                                            // 0x00D8(0x0028)(NoDestructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionStrataWeight">();
	}
	static class UMaterialExpressionStrataWeight* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionStrataWeight>();
	}
};
static_assert(alignof(UMaterialExpressionStrataWeight) == 0x000008, "Wrong alignment on UMaterialExpressionStrataWeight");
static_assert(sizeof(UMaterialExpressionStrataWeight) == 0x000100, "Wrong size on UMaterialExpressionStrataWeight");
static_assert(offsetof(UMaterialExpressionStrataWeight, A) == 0x0000B0, "Member 'UMaterialExpressionStrataWeight::A' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionStrataWeight, Weight) == 0x0000D8, "Member 'UMaterialExpressionStrataWeight::Weight' has a wrong offset!");

// Class Engine.StaticMeshComponent
// 0x0090 (0x0640 - 0x05B0)
class UStaticMeshComponent : public UMeshComponent
{
public:
	int32                                         ForcedLodModel;                                    // 0x05A8(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         PreviousLODLevel;                                  // 0x05AC(0x0004)(ZeroConstructor, Deprecated, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         MinLOD;                                            // 0x05B0(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         SubDivisionStepSize;                               // 0x05B4(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UStaticMesh*                            StaticMesh;                                        // 0x05B8(0x0008)(Edit, BlueprintVisible, BlueprintReadOnly, Net, ZeroConstructor, RepNotify, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	struct FColor                                 WireframeColorOverride;                            // 0x05C0(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bForceNaniteForMasked : 1;                         // 0x05C4(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bDisallowNanite : 1;                               // 0x05C4(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bForceDisableNanite : 1;                           // 0x05C4(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bEvaluateWorldPositionOffset : 1;                  // 0x05C4(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bWorldPositionOffsetWritesVelocity : 1;            // 0x05C4(0x0001)(BitIndex: 0x04, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bEvaluateWorldPositionOffsetInRayTracing : 1;      // 0x05C4(0x0001)(BitIndex: 0x05, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_5C5[0x3];                                      // 0x05C5(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	int32                                         WorldPositionOffsetDisableDistance;                // 0x05C8(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         BitPad_5CC_0 : 1;                                  // 0x05CC(0x0001)(Fixing Bit-Field Size Between Bits [ Dumper-7 ])
	uint8                                         bOverrideWireframeColor : 1;                       // 0x05CC(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bOverrideMinLOD : 1;                               // 0x05CC(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bOverrideNavigationExport : 1;                     // 0x05CC(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (Transient, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bForceNavigationObstacle : 1;                      // 0x05CC(0x0001)(BitIndex: 0x04, PropSize: 0x0001 (Transient, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bDisallowMeshPaintPerInstance : 1;                 // 0x05CC(0x0001)(BitIndex: 0x05, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bIgnoreInstanceForTextureStreaming : 1;            // 0x05CC(0x0001)(BitIndex: 0x06, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bOverrideLightMapRes : 1;                          // 0x05CC(0x0001)(BitIndex: 0x07, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bCastDistanceFieldIndirectShadow : 1;              // 0x05CD(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bOverrideDistanceFieldSelfShadowBias : 1;          // 0x05CD(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bUseSubDivisions : 1;                              // 0x05CD(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bUseDefaultCollision : 1;                          // 0x05CD(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bSortTriangles : 1;                                // 0x05CD(0x0001)(BitIndex: 0x04, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bReverseCulling : 1;                               // 0x05CD(0x0001)(BitIndex: 0x05, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_5CE[0x2];                                      // 0x05CE(0x0002)(Fixing Size After Last Property [ Dumper-7 ])
	int32                                         OverriddenLightMapRes;                             // 0x05D0(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         DistanceFieldIndirectShadowMinVisibility;          // 0x05D4(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         DistanceFieldSelfShadowBias;                       // 0x05D8(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         StreamingDistanceMultiplier;                       // 0x05DC(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TArray<struct FStaticMeshComponentLODInfo>    LODData;                                           // 0x05E0(0x0010)(ZeroConstructor, Transient, NativeAccessSpecifierPublic)
	TArray<struct FStreamingTextureBuildInfo>     StreamingTextureData;                              // 0x05F0(0x0010)(ZeroConstructor, NonTransactional, NativeAccessSpecifierPublic)
	struct FLightmassPrimitiveSettings            LightmassSettings;                                 // 0x0600(0x0018)(Edit, NoDestructor, NativeAccessSpecifierPublic)
	struct FVtsNaniteExtSettings                  NaniteExtensionSettings;                           // 0x0618(0x0014)(Edit, NoDestructor, NativeAccessSpecifierPublic)
	uint8                                         Pad_62C[0x14];                                     // 0x062C(0x0014)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	bool GetInitialEvaluateWorldPositionOffset();
	void OnRep_StaticMesh(class UStaticMesh* OldStaticMesh);
	void SetDistanceFieldSelfShadowBias(float NewValue);
	void SetEvaluateWorldPositionOffset(bool NewValue);
	void SetEvaluateWorldPositionOffsetInRayTracing(bool NewValue);
	void SetForceDisableNanite(bool bInForceDisableNanite);
	void SetForcedLodModel(int32 NewForcedLodModel);
	void SetReverseCulling(bool ReverseCulling);
	bool SetStaticMesh(class UStaticMesh* NewMesh);
	void SetWorldPositionOffsetDisableDistance(int32 NewValue);

	void GetLocalBounds(struct FVector* Min, struct FVector* Max) const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"StaticMeshComponent">();
	}
	static class UStaticMeshComponent* GetDefaultObj()
	{
		return GetDefaultObjImpl<UStaticMeshComponent>();
	}
};
static_assert(alignof(UStaticMeshComponent) == 0x000010, "Wrong alignment on UStaticMeshComponent");
static_assert(sizeof(UStaticMeshComponent) == 0x000640, "Wrong size on UStaticMeshComponent");
static_assert(offsetof(UStaticMeshComponent, ForcedLodModel) == 0x0005A8, "Member 'UStaticMeshComponent::ForcedLodModel' has a wrong offset!");
static_assert(offsetof(UStaticMeshComponent, PreviousLODLevel) == 0x0005AC, "Member 'UStaticMeshComponent::PreviousLODLevel' has a wrong offset!");
static_assert(offsetof(UStaticMeshComponent, MinLOD) == 0x0005B0, "Member 'UStaticMeshComponent::MinLOD' has a wrong offset!");
static_assert(offsetof(UStaticMeshComponent, SubDivisionStepSize) == 0x0005B4, "Member 'UStaticMeshComponent::SubDivisionStepSize' has a wrong offset!");
static_assert(offsetof(UStaticMeshComponent, StaticMesh) == 0x0005B8, "Member 'UStaticMeshComponent::StaticMesh' has a wrong offset!");
static_assert(offsetof(UStaticMeshComponent, WireframeColorOverride) == 0x0005C0, "Member 'UStaticMeshComponent::WireframeColorOverride' has a wrong offset!");
static_assert(offsetof(UStaticMeshComponent, WorldPositionOffsetDisableDistance) == 0x0005C8, "Member 'UStaticMeshComponent::WorldPositionOffsetDisableDistance' has a wrong offset!");
static_assert(offsetof(UStaticMeshComponent, OverriddenLightMapRes) == 0x0005D0, "Member 'UStaticMeshComponent::OverriddenLightMapRes' has a wrong offset!");
static_assert(offsetof(UStaticMeshComponent, DistanceFieldIndirectShadowMinVisibility) == 0x0005D4, "Member 'UStaticMeshComponent::DistanceFieldIndirectShadowMinVisibility' has a wrong offset!");
static_assert(offsetof(UStaticMeshComponent, DistanceFieldSelfShadowBias) == 0x0005D8, "Member 'UStaticMeshComponent::DistanceFieldSelfShadowBias' has a wrong offset!");
static_assert(offsetof(UStaticMeshComponent, StreamingDistanceMultiplier) == 0x0005DC, "Member 'UStaticMeshComponent::StreamingDistanceMultiplier' has a wrong offset!");
static_assert(offsetof(UStaticMeshComponent, LODData) == 0x0005E0, "Member 'UStaticMeshComponent::LODData' has a wrong offset!");
static_assert(offsetof(UStaticMeshComponent, StreamingTextureData) == 0x0005F0, "Member 'UStaticMeshComponent::StreamingTextureData' has a wrong offset!");
static_assert(offsetof(UStaticMeshComponent, LightmassSettings) == 0x000600, "Member 'UStaticMeshComponent::LightmassSettings' has a wrong offset!");
static_assert(offsetof(UStaticMeshComponent, NaniteExtensionSettings) == 0x000618, "Member 'UStaticMeshComponent::NaniteExtensionSettings' has a wrong offset!");

// Class Engine.MaterialExpressionStrataUtilityBase
// 0x0000 (0x00B0 - 0x00B0)
class UMaterialExpressionStrataUtilityBase : public UMaterialExpression
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionStrataUtilityBase">();
	}
	static class UMaterialExpressionStrataUtilityBase* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionStrataUtilityBase>();
	}
};
static_assert(alignof(UMaterialExpressionStrataUtilityBase) == 0x000008, "Wrong alignment on UMaterialExpressionStrataUtilityBase");
static_assert(sizeof(UMaterialExpressionStrataUtilityBase) == 0x0000B0, "Wrong size on UMaterialExpressionStrataUtilityBase");

// Class Engine.InstancedStaticMeshComponent
// 0x0150 (0x0790 - 0x0640)
#pragma pack(push, 0x1)
class alignas(0x10) UInstancedStaticMeshComponent : public UStaticMeshComponent
{
public:
	uint8                                         Pad_640[0x8];                                      // 0x0640(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<struct FInstancedStaticMeshInstanceData> PerInstanceSMData;                               // 0x0648(0x0010)(Edit, ZeroConstructor, NativeAccessSpecifierPublic)
	TArray<struct FMatrix>                        PerInstancePrevTransform;                          // 0x0658(0x0010)(ZeroConstructor, Transient, NativeAccessSpecifierPublic)
	int32                                         NumCustomDataFloats;                               // 0x0668(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_66C[0x4];                                      // 0x066C(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<float>                                 PerInstanceSMCustomData;                           // 0x0670(0x0010)(Edit, EditFixedSize, ZeroConstructor, AdvancedDisplay, NativeAccessSpecifierPublic)
	int32                                         InstancingRandomSeed;                              // 0x0680(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_684[0x4];                                      // 0x0684(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<struct FInstancedStaticMeshRandomSeed> AdditionalRandomSeeds;                             // 0x0688(0x0010)(ZeroConstructor, NativeAccessSpecifierPublic)
	int32                                         InstanceStartCullDistance;                         // 0x0698(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         InstanceEndCullDistance;                           // 0x069C(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TArray<int32>                                 InstanceReorderTable;                              // 0x06A0(0x0010)(ZeroConstructor, NativeAccessSpecifierPublic)
	uint8                                         Pad_6B0[0xC4];                                     // 0x06B0(0x00C4)(Fixing Size After Last Property [ Dumper-7 ])
	int32                                         NumPendingLightmaps;                               // 0x0774(0x0004)(ZeroConstructor, Transient, DuplicateTransient, IsPlainOldData, NoDestructor, Protected, TextExportTransient, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	TArray<struct FInstancedStaticMeshMappingInfo> CachedMappings;                                   // 0x0778(0x0010)(ZeroConstructor, Transient, DuplicateTransient, Protected, TextExportTransient, NativeAccessSpecifierProtected)

public:
	int32 AddInstance(const struct FTransform& InstanceTransform, bool bWorldSpace);
	TArray<int32> AddInstances(const TArray<struct FTransform>& InstanceTransforms, bool bShouldReturnIndices, bool bWorldSpace);
	int32 AddInstanceWorldSpace(const struct FTransform& WorldTransform);
	bool BatchUpdateInstancesTransform(int32 StartInstanceIndex, int32 NumInstances, const struct FTransform& NewInstancesTransform, bool bWorldSpace, bool bMarkRenderStateDirty, bool bTeleport);
	bool BatchUpdateInstancesTransforms(int32 StartInstanceIndex, const TArray<struct FTransform>& NewInstancesTransforms, bool bWorldSpace, bool bMarkRenderStateDirty, bool bTeleport);
	void ClearInstances();
	bool RemoveInstance(int32 InstanceIndex);
	bool RemoveInstances(const TArray<int32>& InstancesToRemove);
	void SetCullDistances(int32 StartCullDistance, int32 EndCullDistance);
	bool SetCustomDataValue(int32 InstanceIndex, int32 CustomDataIndex, float CustomDataValue, bool bMarkRenderStateDirty);
	void SetNumCustomDataFloats(int32 InNumCustomDataFloats);
	bool UpdateInstanceTransform(int32 InstanceIndex, const struct FTransform& NewInstanceTransform, bool bWorldSpace, bool bMarkRenderStateDirty, bool bTeleport);

	void GetCullDistances(int32* OutStartCullDistance, int32* OutEndCullDistance) const;
	int32 GetInstanceCount() const;
	TArray<int32> GetInstancesOverlappingBox(const struct FBox& Box, bool bBoxInWorldSpace) const;
	TArray<int32> GetInstancesOverlappingSphere(const struct FVector& Center, float Radius, bool bSphereInWorldSpace) const;
	bool GetInstanceTransform(int32 InstanceIndex, struct FTransform* OutInstanceTransform, bool bWorldSpace) const;
	bool IsValidInstance(int32 InstanceIndex) const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"InstancedStaticMeshComponent">();
	}
	static class UInstancedStaticMeshComponent* GetDefaultObj()
	{
		return GetDefaultObjImpl<UInstancedStaticMeshComponent>();
	}
};
#pragma pack(pop)
static_assert(alignof(UInstancedStaticMeshComponent) == 0x000010, "Wrong alignment on UInstancedStaticMeshComponent");
static_assert(sizeof(UInstancedStaticMeshComponent) == 0x000790, "Wrong size on UInstancedStaticMeshComponent");
static_assert(offsetof(UInstancedStaticMeshComponent, PerInstanceSMData) == 0x000648, "Member 'UInstancedStaticMeshComponent::PerInstanceSMData' has a wrong offset!");
static_assert(offsetof(UInstancedStaticMeshComponent, PerInstancePrevTransform) == 0x000658, "Member 'UInstancedStaticMeshComponent::PerInstancePrevTransform' has a wrong offset!");
static_assert(offsetof(UInstancedStaticMeshComponent, NumCustomDataFloats) == 0x000668, "Member 'UInstancedStaticMeshComponent::NumCustomDataFloats' has a wrong offset!");
static_assert(offsetof(UInstancedStaticMeshComponent, PerInstanceSMCustomData) == 0x000670, "Member 'UInstancedStaticMeshComponent::PerInstanceSMCustomData' has a wrong offset!");
static_assert(offsetof(UInstancedStaticMeshComponent, InstancingRandomSeed) == 0x000680, "Member 'UInstancedStaticMeshComponent::InstancingRandomSeed' has a wrong offset!");
static_assert(offsetof(UInstancedStaticMeshComponent, AdditionalRandomSeeds) == 0x000688, "Member 'UInstancedStaticMeshComponent::AdditionalRandomSeeds' has a wrong offset!");
static_assert(offsetof(UInstancedStaticMeshComponent, InstanceStartCullDistance) == 0x000698, "Member 'UInstancedStaticMeshComponent::InstanceStartCullDistance' has a wrong offset!");
static_assert(offsetof(UInstancedStaticMeshComponent, InstanceEndCullDistance) == 0x00069C, "Member 'UInstancedStaticMeshComponent::InstanceEndCullDistance' has a wrong offset!");
static_assert(offsetof(UInstancedStaticMeshComponent, InstanceReorderTable) == 0x0006A0, "Member 'UInstancedStaticMeshComponent::InstanceReorderTable' has a wrong offset!");
static_assert(offsetof(UInstancedStaticMeshComponent, NumPendingLightmaps) == 0x000774, "Member 'UInstancedStaticMeshComponent::NumPendingLightmaps' has a wrong offset!");
static_assert(offsetof(UInstancedStaticMeshComponent, CachedMappings) == 0x000778, "Member 'UInstancedStaticMeshComponent::CachedMappings' has a wrong offset!");

// Class Engine.ParticleModuleLocationBase
// 0x0000 (0x0030 - 0x0030)
class UParticleModuleLocationBase : public UParticleModule
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ParticleModuleLocationBase">();
	}
	static class UParticleModuleLocationBase* GetDefaultObj()
	{
		return GetDefaultObjImpl<UParticleModuleLocationBase>();
	}
};
static_assert(alignof(UParticleModuleLocationBase) == 0x000008, "Wrong alignment on UParticleModuleLocationBase");
static_assert(sizeof(UParticleModuleLocationBase) == 0x000030, "Wrong size on UParticleModuleLocationBase");

// Class Engine.ParticleModuleLocationPrimitiveBase
// 0x0098 (0x00C8 - 0x0030)
class UParticleModuleLocationPrimitiveBase : public UParticleModuleLocationBase
{
public:
	uint8                                         Positive_X : 1;                                    // 0x0030(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Positive_Y : 1;                                    // 0x0030(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Positive_Z : 1;                                    // 0x0030(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Negative_X : 1;                                    // 0x0030(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Negative_Y : 1;                                    // 0x0030(0x0001)(BitIndex: 0x04, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Negative_Z : 1;                                    // 0x0030(0x0001)(BitIndex: 0x05, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         SurfaceOnly : 1;                                   // 0x0030(0x0001)(BitIndex: 0x06, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Velocity : 1;                                      // 0x0030(0x0001)(BitIndex: 0x07, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_31[0x7];                                       // 0x0031(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	struct FRawDistributionFloat                  VelocityScale;                                     // 0x0038(0x0030)(Edit, ContainsInstancedReference, NativeAccessSpecifierPublic)
	struct FRawDistributionVector                 StartLocation;                                     // 0x0068(0x0060)(Edit, ContainsInstancedReference, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ParticleModuleLocationPrimitiveBase">();
	}
	static class UParticleModuleLocationPrimitiveBase* GetDefaultObj()
	{
		return GetDefaultObjImpl<UParticleModuleLocationPrimitiveBase>();
	}
};
static_assert(alignof(UParticleModuleLocationPrimitiveBase) == 0x000008, "Wrong alignment on UParticleModuleLocationPrimitiveBase");
static_assert(sizeof(UParticleModuleLocationPrimitiveBase) == 0x0000C8, "Wrong size on UParticleModuleLocationPrimitiveBase");
static_assert(offsetof(UParticleModuleLocationPrimitiveBase, VelocityScale) == 0x000038, "Member 'UParticleModuleLocationPrimitiveBase::VelocityScale' has a wrong offset!");
static_assert(offsetof(UParticleModuleLocationPrimitiveBase, StartLocation) == 0x000068, "Member 'UParticleModuleLocationPrimitiveBase::StartLocation' has a wrong offset!");

// Class Engine.ParticleModuleLocationPrimitiveSphere
// 0x0030 (0x00F8 - 0x00C8)
class UParticleModuleLocationPrimitiveSphere : public UParticleModuleLocationPrimitiveBase
{
public:
	struct FRawDistributionFloat                  StartRadius;                                       // 0x00C8(0x0030)(Edit, ContainsInstancedReference, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ParticleModuleLocationPrimitiveSphere">();
	}
	static class UParticleModuleLocationPrimitiveSphere* GetDefaultObj()
	{
		return GetDefaultObjImpl<UParticleModuleLocationPrimitiveSphere>();
	}
};
static_assert(alignof(UParticleModuleLocationPrimitiveSphere) == 0x000008, "Wrong alignment on UParticleModuleLocationPrimitiveSphere");
static_assert(sizeof(UParticleModuleLocationPrimitiveSphere) == 0x0000F8, "Wrong size on UParticleModuleLocationPrimitiveSphere");
static_assert(offsetof(UParticleModuleLocationPrimitiveSphere, StartRadius) == 0x0000C8, "Member 'UParticleModuleLocationPrimitiveSphere::StartRadius' has a wrong offset!");

// Class Engine.ParticleModuleAccelerationBase
// 0x0008 (0x0038 - 0x0030)
class UParticleModuleAccelerationBase : public UParticleModule
{
public:
	uint8                                         bAlwaysInWorldSpace : 1;                           // 0x0030(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_31[0x7];                                       // 0x0031(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ParticleModuleAccelerationBase">();
	}
	static class UParticleModuleAccelerationBase* GetDefaultObj()
	{
		return GetDefaultObjImpl<UParticleModuleAccelerationBase>();
	}
};
static_assert(alignof(UParticleModuleAccelerationBase) == 0x000008, "Wrong alignment on UParticleModuleAccelerationBase");
static_assert(sizeof(UParticleModuleAccelerationBase) == 0x000038, "Wrong size on UParticleModuleAccelerationBase");

// Class Engine.ParticleModuleAcceleration
// 0x0068 (0x00A0 - 0x0038)
class UParticleModuleAcceleration final : public UParticleModuleAccelerationBase
{
public:
	struct FRawDistributionVector                 Acceleration;                                      // 0x0038(0x0060)(Edit, ContainsInstancedReference, NativeAccessSpecifierPublic)
	uint8                                         bApplyOwnerScale : 1;                              // 0x0098(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_99[0x7];                                       // 0x0099(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ParticleModuleAcceleration">();
	}
	static class UParticleModuleAcceleration* GetDefaultObj()
	{
		return GetDefaultObjImpl<UParticleModuleAcceleration>();
	}
};
static_assert(alignof(UParticleModuleAcceleration) == 0x000008, "Wrong alignment on UParticleModuleAcceleration");
static_assert(sizeof(UParticleModuleAcceleration) == 0x0000A0, "Wrong size on UParticleModuleAcceleration");
static_assert(offsetof(UParticleModuleAcceleration, Acceleration) == 0x000038, "Member 'UParticleModuleAcceleration::Acceleration' has a wrong offset!");

// Class Engine.MovementComponent
// 0x0068 (0x0110 - 0x00A8)
class UMovementComponent : public UActorComponent
{
public:
	class USceneComponent*                        UpdatedComponent;                                  // 0x00A8(0x0008)(BlueprintVisible, ExportObject, BlueprintReadOnly, ZeroConstructor, Transient, InstancedReference, DuplicateTransient, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UPrimitiveComponent*                    UpdatedPrimitive;                                  // 0x00B0(0x0008)(BlueprintVisible, ExportObject, BlueprintReadOnly, ZeroConstructor, Transient, InstancedReference, DuplicateTransient, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_B8[0x8];                                       // 0x00B8(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	struct FVector                                Velocity;                                          // 0x00C0(0x0018)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector                                PlaneConstraintNormal;                             // 0x00D8(0x0018)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	struct FVector                                PlaneConstraintOrigin;                             // 0x00F0(0x0018)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         bUpdateOnlyIfRendered : 1;                         // 0x0108(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bAutoUpdateTickRegistration : 1;                   // 0x0108(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bTickBeforeOwner : 1;                              // 0x0108(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bAutoRegisterUpdatedComponent : 1;                 // 0x0108(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bConstrainToPlane : 1;                             // 0x0108(0x0001)(BitIndex: 0x04, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bSnapToPlaneAtStart : 1;                           // 0x0108(0x0001)(BitIndex: 0x05, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bAutoRegisterPhysicsVolumeUpdates : 1;             // 0x0108(0x0001)(BitIndex: 0x06, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bComponentShouldUpdatePhysicsVolume : 1;           // 0x0108(0x0001)(BitIndex: 0x07, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_109[0x2];                                      // 0x0109(0x0002)(Fixing Size After Last Property [ Dumper-7 ])
	EPlaneConstraintAxisSetting                   PlaneConstraintAxisSetting;                        // 0x010B(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_10C[0x4];                                      // 0x010C(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	bool K2_MoveUpdatedComponent(const struct FVector& Delta, const struct FRotator& NewRotation, struct FHitResult* OutHit, bool bSweep, bool bTeleport);
	void PhysicsVolumeChanged(class APhysicsVolume* NewVolume);
	void SetPlaneConstraintAxisSetting(EPlaneConstraintAxisSetting NewAxisSetting);
	void SetPlaneConstraintEnabled(bool bEnabled);
	void SetPlaneConstraintFromVectors(const struct FVector& Forward, const struct FVector& Up);
	void SetPlaneConstraintNormal(const struct FVector& PlaneNormal);
	void SetPlaneConstraintOrigin(const struct FVector& PlaneOrigin);
	void SetUpdatedComponent(class USceneComponent* NewUpdatedComponent);
	void SnapUpdatedComponentToPlane();
	void StopMovementImmediately();

	struct FVector ConstrainDirectionToPlane(const struct FVector& Direction) const;
	struct FVector ConstrainLocationToPlane(const struct FVector& Location) const;
	struct FVector ConstrainNormalToPlane(const struct FVector& Normal) const;
	float GetGravityZ() const;
	float GetMaxSpeed() const;
	class APhysicsVolume* GetPhysicsVolume() const;
	EPlaneConstraintAxisSetting GetPlaneConstraintAxisSetting() const;
	const struct FVector GetPlaneConstraintNormal() const;
	const struct FVector GetPlaneConstraintOrigin() const;
	bool IsExceedingMaxSpeed(float MaxSpeed) const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MovementComponent">();
	}
	static class UMovementComponent* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMovementComponent>();
	}
};
static_assert(alignof(UMovementComponent) == 0x000008, "Wrong alignment on UMovementComponent");
static_assert(sizeof(UMovementComponent) == 0x000110, "Wrong size on UMovementComponent");
static_assert(offsetof(UMovementComponent, UpdatedComponent) == 0x0000A8, "Member 'UMovementComponent::UpdatedComponent' has a wrong offset!");
static_assert(offsetof(UMovementComponent, UpdatedPrimitive) == 0x0000B0, "Member 'UMovementComponent::UpdatedPrimitive' has a wrong offset!");
static_assert(offsetof(UMovementComponent, Velocity) == 0x0000C0, "Member 'UMovementComponent::Velocity' has a wrong offset!");
static_assert(offsetof(UMovementComponent, PlaneConstraintNormal) == 0x0000D8, "Member 'UMovementComponent::PlaneConstraintNormal' has a wrong offset!");
static_assert(offsetof(UMovementComponent, PlaneConstraintOrigin) == 0x0000F0, "Member 'UMovementComponent::PlaneConstraintOrigin' has a wrong offset!");
static_assert(offsetof(UMovementComponent, PlaneConstraintAxisSetting) == 0x00010B, "Member 'UMovementComponent::PlaneConstraintAxisSetting' has a wrong offset!");

// Class Engine.RotatingMovementComponent
// 0x0038 (0x0148 - 0x0110)
class URotatingMovementComponent final : public UMovementComponent
{
public:
	struct FRotator                               RotationRate;                                      // 0x0110(0x0018)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
	struct FVector                                PivotTranslation;                                  // 0x0128(0x0018)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bRotationInLocalSpace : 1;                         // 0x0140(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_141[0x7];                                      // 0x0141(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"RotatingMovementComponent">();
	}
	static class URotatingMovementComponent* GetDefaultObj()
	{
		return GetDefaultObjImpl<URotatingMovementComponent>();
	}
};
static_assert(alignof(URotatingMovementComponent) == 0x000008, "Wrong alignment on URotatingMovementComponent");
static_assert(sizeof(URotatingMovementComponent) == 0x000148, "Wrong size on URotatingMovementComponent");
static_assert(offsetof(URotatingMovementComponent, RotationRate) == 0x000110, "Member 'URotatingMovementComponent::RotationRate' has a wrong offset!");
static_assert(offsetof(URotatingMovementComponent, PivotTranslation) == 0x000128, "Member 'URotatingMovementComponent::PivotTranslation' has a wrong offset!");

// Class Engine.PartitionActor
// 0x0000 (0x02A0 - 0x02A0)
class APartitionActor : public AActor
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"PartitionActor">();
	}
	static class APartitionActor* GetDefaultObj()
	{
		return GetDefaultObjImpl<APartitionActor>();
	}
};
static_assert(alignof(APartitionActor) == 0x000008, "Wrong alignment on APartitionActor");
static_assert(sizeof(APartitionActor) == 0x0002A0, "Wrong size on APartitionActor");

// Class Engine.ISMPartitionActor
// 0x0010 (0x02B0 - 0x02A0)
class AISMPartitionActor : public APartitionActor
{
public:
	uint8                                         Pad_2A0[0x10];                                     // 0x02A0(0x0010)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ISMPartitionActor">();
	}
	static class AISMPartitionActor* GetDefaultObj()
	{
		return GetDefaultObjImpl<AISMPartitionActor>();
	}
};
static_assert(alignof(AISMPartitionActor) == 0x000008, "Wrong alignment on AISMPartitionActor");
static_assert(sizeof(AISMPartitionActor) == 0x0002B0, "Wrong size on AISMPartitionActor");

// Class Engine.AnimationAsset
// 0x0058 (0x0080 - 0x0028)
class UAnimationAsset : public UObject
{
public:
	uint8                                         Pad_28[0x10];                                      // 0x0028(0x0010)(Fixing Size After Last Property [ Dumper-7 ])
	class USkeleton*                              Skeleton;                                          // 0x0038(0x0008)(Edit, ZeroConstructor, EditConst, NoDestructor, AssetRegistrySearchable, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_40[0x20];                                      // 0x0040(0x0020)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<class UAnimMetaData*>                  MetaData;                                          // 0x0060(0x0010)(Edit, ExportObject, ZeroConstructor, ContainsInstancedReference, UObjectWrapper, NativeAccessSpecifierPrivate)
	TArray<class UAssetUserData*>                 AssetUserData;                                     // 0x0070(0x0010)(Edit, ExportObject, ZeroConstructor, ContainsInstancedReference, AdvancedDisplay, Protected, UObjectWrapper, NativeAccessSpecifierProtected)

public:
	float GetPlayLength() const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AnimationAsset">();
	}
	static class UAnimationAsset* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAnimationAsset>();
	}
};
static_assert(alignof(UAnimationAsset) == 0x000008, "Wrong alignment on UAnimationAsset");
static_assert(sizeof(UAnimationAsset) == 0x000080, "Wrong size on UAnimationAsset");
static_assert(offsetof(UAnimationAsset, Skeleton) == 0x000038, "Member 'UAnimationAsset::Skeleton' has a wrong offset!");
static_assert(offsetof(UAnimationAsset, MetaData) == 0x000060, "Member 'UAnimationAsset::MetaData' has a wrong offset!");
static_assert(offsetof(UAnimationAsset, AssetUserData) == 0x000070, "Member 'UAnimationAsset::AssetUserData' has a wrong offset!");

// Class Engine.AnimSequenceBase
// 0x0030 (0x00B0 - 0x0080)
class UAnimSequenceBase : public UAnimationAsset
{
public:
	TArray<struct FAnimNotifyEvent>               Notifies;                                          // 0x0080(0x0010)(ZeroConstructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
	float                                         SequenceLength;                                    // 0x0090(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, EditConst, IsPlainOldData, NoDestructor, AssetRegistrySearchable, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_94[0x4];                                       // 0x0094(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	struct FRawCurveTracks                        RawCurveData;                                      // 0x0098(0x0010)(Protected, NativeAccessSpecifierProtected)
	float                                         RateScale;                                         // 0x00A8(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bLoop;                                             // 0x00AC(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_AD[0x3];                                       // 0x00AD(0x0003)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AnimSequenceBase">();
	}
	static class UAnimSequenceBase* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAnimSequenceBase>();
	}
};
static_assert(alignof(UAnimSequenceBase) == 0x000008, "Wrong alignment on UAnimSequenceBase");
static_assert(sizeof(UAnimSequenceBase) == 0x0000B0, "Wrong size on UAnimSequenceBase");
static_assert(offsetof(UAnimSequenceBase, Notifies) == 0x000080, "Member 'UAnimSequenceBase::Notifies' has a wrong offset!");
static_assert(offsetof(UAnimSequenceBase, SequenceLength) == 0x000090, "Member 'UAnimSequenceBase::SequenceLength' has a wrong offset!");
static_assert(offsetof(UAnimSequenceBase, RawCurveData) == 0x000098, "Member 'UAnimSequenceBase::RawCurveData' has a wrong offset!");
static_assert(offsetof(UAnimSequenceBase, RateScale) == 0x0000A8, "Member 'UAnimSequenceBase::RateScale' has a wrong offset!");
static_assert(offsetof(UAnimSequenceBase, bLoop) == 0x0000AC, "Member 'UAnimSequenceBase::bLoop' has a wrong offset!");

// Class Engine.MaterialExpressionStrataTransmittanceToMFP
// 0x0050 (0x0100 - 0x00B0)
class UMaterialExpressionStrataTransmittanceToMFP final : public UMaterialExpressionStrataUtilityBase
{
public:
	struct FExpressionInput                       TransmittanceColor;                                // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       Thickness;                                         // 0x00D8(0x0028)(NoDestructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionStrataTransmittanceToMFP">();
	}
	static class UMaterialExpressionStrataTransmittanceToMFP* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionStrataTransmittanceToMFP>();
	}
};
static_assert(alignof(UMaterialExpressionStrataTransmittanceToMFP) == 0x000008, "Wrong alignment on UMaterialExpressionStrataTransmittanceToMFP");
static_assert(sizeof(UMaterialExpressionStrataTransmittanceToMFP) == 0x000100, "Wrong size on UMaterialExpressionStrataTransmittanceToMFP");
static_assert(offsetof(UMaterialExpressionStrataTransmittanceToMFP, TransmittanceColor) == 0x0000B0, "Member 'UMaterialExpressionStrataTransmittanceToMFP::TransmittanceColor' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionStrataTransmittanceToMFP, Thickness) == 0x0000D8, "Member 'UMaterialExpressionStrataTransmittanceToMFP::Thickness' has a wrong offset!");

// Class Engine.NavigationObjectBase
// 0x0028 (0x02C8 - 0x02A0)
class ANavigationObjectBase : public AActor
{
public:
	uint8                                         Pad_2A0[0x8];                                      // 0x02A0(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	class UCapsuleComponent*                      CapsuleComponent;                                  // 0x02A8(0x0008)(ExportObject, ZeroConstructor, InstancedReference, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	class UBillboardComponent*                    GoodSprite;                                        // 0x02B0(0x0008)(ExportObject, ZeroConstructor, InstancedReference, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	class UBillboardComponent*                    BadSprite;                                         // 0x02B8(0x0008)(ExportObject, ZeroConstructor, InstancedReference, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         bIsPIEPlayerStart : 1;                             // 0x02C0(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_2C1[0x7];                                      // 0x02C1(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"NavigationObjectBase">();
	}
	static class ANavigationObjectBase* GetDefaultObj()
	{
		return GetDefaultObjImpl<ANavigationObjectBase>();
	}
};
static_assert(alignof(ANavigationObjectBase) == 0x000008, "Wrong alignment on ANavigationObjectBase");
static_assert(sizeof(ANavigationObjectBase) == 0x0002C8, "Wrong size on ANavigationObjectBase");
static_assert(offsetof(ANavigationObjectBase, CapsuleComponent) == 0x0002A8, "Member 'ANavigationObjectBase::CapsuleComponent' has a wrong offset!");
static_assert(offsetof(ANavigationObjectBase, GoodSprite) == 0x0002B0, "Member 'ANavigationObjectBase::GoodSprite' has a wrong offset!");
static_assert(offsetof(ANavigationObjectBase, BadSprite) == 0x0002B8, "Member 'ANavigationObjectBase::BadSprite' has a wrong offset!");

// Class Engine.HierarchicalInstancedStaticMeshComponent
// 0x0190 (0x0920 - 0x0790)
#pragma pack(push, 0x1)
class alignas(0x10) UHierarchicalInstancedStaticMeshComponent : public UInstancedStaticMeshComponent
{
public:
	uint8                                         Pad_788[0x10];                                     // 0x0788(0x0010)(Fixing Size After Last Property [ Dumper-7 ])
	uint8                                         bUseTranslatedInstanceSpace : 1;                   // 0x0798(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_799[0x7];                                      // 0x0799(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	struct FVector                                TranslatedInstanceSpaceOrigin;                     // 0x07A0(0x0018)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TArray<int32>                                 SortedInstances;                                   // 0x07B8(0x0010)(ZeroConstructor, NativeAccessSpecifierPublic)
	int32                                         NumBuiltInstances;                                 // 0x07C8(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_7CC[0x4];                                      // 0x07CC(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	struct FBox                                   BuiltInstanceBounds;                               // 0x07D0(0x0038)(ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
	struct FBox                                   UnbuiltInstanceBounds;                             // 0x0808(0x0038)(ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
	TArray<struct FBox>                           UnbuiltInstanceBoundsList;                         // 0x0840(0x0010)(ZeroConstructor, NativeAccessSpecifierPublic)
	uint8                                         bEnableDensityScaling : 1;                         // 0x0850(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_851[0x7];                                      // 0x0851(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         InstanceLODDistanceScale;                          // 0x0858(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         OcclusionLayerNumNodes;                            // 0x085C(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FBoxSphereBounds                       CacheMeshExtendedBounds;                           // 0x0860(0x0038)(ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
	bool                                          bDisableCollision;                                 // 0x0898(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_899[0x3];                                      // 0x0899(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	int32                                         InstanceCountToRender;                             // 0x089C(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_8A0[0x78];                                     // 0x08A0(0x0078)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void SetLODDistanceScale(float InLODDistanceScale);

	float GetLODDistanceScale() const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"HierarchicalInstancedStaticMeshComponent">();
	}
	static class UHierarchicalInstancedStaticMeshComponent* GetDefaultObj()
	{
		return GetDefaultObjImpl<UHierarchicalInstancedStaticMeshComponent>();
	}
};
#pragma pack(pop)
static_assert(alignof(UHierarchicalInstancedStaticMeshComponent) == 0x000010, "Wrong alignment on UHierarchicalInstancedStaticMeshComponent");
static_assert(sizeof(UHierarchicalInstancedStaticMeshComponent) == 0x000920, "Wrong size on UHierarchicalInstancedStaticMeshComponent");
static_assert(offsetof(UHierarchicalInstancedStaticMeshComponent, TranslatedInstanceSpaceOrigin) == 0x0007A0, "Member 'UHierarchicalInstancedStaticMeshComponent::TranslatedInstanceSpaceOrigin' has a wrong offset!");
static_assert(offsetof(UHierarchicalInstancedStaticMeshComponent, SortedInstances) == 0x0007B8, "Member 'UHierarchicalInstancedStaticMeshComponent::SortedInstances' has a wrong offset!");
static_assert(offsetof(UHierarchicalInstancedStaticMeshComponent, NumBuiltInstances) == 0x0007C8, "Member 'UHierarchicalInstancedStaticMeshComponent::NumBuiltInstances' has a wrong offset!");
static_assert(offsetof(UHierarchicalInstancedStaticMeshComponent, BuiltInstanceBounds) == 0x0007D0, "Member 'UHierarchicalInstancedStaticMeshComponent::BuiltInstanceBounds' has a wrong offset!");
static_assert(offsetof(UHierarchicalInstancedStaticMeshComponent, UnbuiltInstanceBounds) == 0x000808, "Member 'UHierarchicalInstancedStaticMeshComponent::UnbuiltInstanceBounds' has a wrong offset!");
static_assert(offsetof(UHierarchicalInstancedStaticMeshComponent, UnbuiltInstanceBoundsList) == 0x000840, "Member 'UHierarchicalInstancedStaticMeshComponent::UnbuiltInstanceBoundsList' has a wrong offset!");
static_assert(offsetof(UHierarchicalInstancedStaticMeshComponent, InstanceLODDistanceScale) == 0x000858, "Member 'UHierarchicalInstancedStaticMeshComponent::InstanceLODDistanceScale' has a wrong offset!");
static_assert(offsetof(UHierarchicalInstancedStaticMeshComponent, OcclusionLayerNumNodes) == 0x00085C, "Member 'UHierarchicalInstancedStaticMeshComponent::OcclusionLayerNumNodes' has a wrong offset!");
static_assert(offsetof(UHierarchicalInstancedStaticMeshComponent, CacheMeshExtendedBounds) == 0x000860, "Member 'UHierarchicalInstancedStaticMeshComponent::CacheMeshExtendedBounds' has a wrong offset!");
static_assert(offsetof(UHierarchicalInstancedStaticMeshComponent, bDisableCollision) == 0x000898, "Member 'UHierarchicalInstancedStaticMeshComponent::bDisableCollision' has a wrong offset!");
static_assert(offsetof(UHierarchicalInstancedStaticMeshComponent, InstanceCountToRender) == 0x00089C, "Member 'UHierarchicalInstancedStaticMeshComponent::InstanceCountToRender' has a wrong offset!");

// Class Engine.MaterialExpressionSamplePhysicsIntegerField
// 0x0030 (0x00E0 - 0x00B0)
class UMaterialExpressionSamplePhysicsIntegerField final : public UMaterialExpression
{
public:
	struct FExpressionInput                       WorldPosition;                                     // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	EFieldIntegerType                             FieldTarget;                                       // 0x00D8(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_D9[0x7];                                       // 0x00D9(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionSamplePhysicsIntegerField">();
	}
	static class UMaterialExpressionSamplePhysicsIntegerField* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionSamplePhysicsIntegerField>();
	}
};
static_assert(alignof(UMaterialExpressionSamplePhysicsIntegerField) == 0x000008, "Wrong alignment on UMaterialExpressionSamplePhysicsIntegerField");
static_assert(sizeof(UMaterialExpressionSamplePhysicsIntegerField) == 0x0000E0, "Wrong size on UMaterialExpressionSamplePhysicsIntegerField");
static_assert(offsetof(UMaterialExpressionSamplePhysicsIntegerField, WorldPosition) == 0x0000B0, "Member 'UMaterialExpressionSamplePhysicsIntegerField::WorldPosition' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionSamplePhysicsIntegerField, FieldTarget) == 0x0000D8, "Member 'UMaterialExpressionSamplePhysicsIntegerField::FieldTarget' has a wrong offset!");

// Class Engine.AnimationDataModelNotifiesExtensions
// 0x0000 (0x0028 - 0x0028)
class UAnimationDataModelNotifiesExtensions final : public UBlueprintFunctionLibrary
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AnimationDataModelNotifiesExtensions">();
	}
	static class UAnimationDataModelNotifiesExtensions* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAnimationDataModelNotifiesExtensions>();
	}
};
static_assert(alignof(UAnimationDataModelNotifiesExtensions) == 0x000008, "Wrong alignment on UAnimationDataModelNotifiesExtensions");
static_assert(sizeof(UAnimationDataModelNotifiesExtensions) == 0x000028, "Wrong size on UAnimationDataModelNotifiesExtensions");

// Class Engine.InputDeviceProperty
// 0x0008 (0x0030 - 0x0028)
class UInputDeviceProperty : public UObject
{
public:
	float                                         PropertyDuration;                                  // 0x0028(0x0004)(Edit, BlueprintVisible, ZeroConstructor, EditConst, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_2C[0x4];                                       // 0x002C(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void ApplyDeviceProperty(const struct FPlatformUserId& UserId, const struct FInputDeviceId& DeviceID);
	void EvaluateDeviceProperty(const struct FPlatformUserId& PlatformUser, const struct FInputDeviceId& DeviceID, const float DeltaTime, const float Duration);
	void ResetDeviceProperty(const struct FPlatformUserId& PlatformUser, const struct FInputDeviceId& DeviceID, bool bForceReset);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"InputDeviceProperty">();
	}
	static class UInputDeviceProperty* GetDefaultObj()
	{
		return GetDefaultObjImpl<UInputDeviceProperty>();
	}
};
static_assert(alignof(UInputDeviceProperty) == 0x000008, "Wrong alignment on UInputDeviceProperty");
static_assert(sizeof(UInputDeviceProperty) == 0x000030, "Wrong size on UInputDeviceProperty");
static_assert(offsetof(UInputDeviceProperty, PropertyDuration) == 0x000028, "Member 'UInputDeviceProperty::PropertyDuration' has a wrong offset!");

// Class Engine.InputDeviceTriggerEffect
// 0x0010 (0x0040 - 0x0030)
class UInputDeviceTriggerEffect : public UInputDeviceProperty
{
public:
	struct FDeviceTriggerBaseData                 BaseTriggerData;                                   // 0x0030(0x0002)(Edit, BlueprintVisible, NoDestructor, NativeAccessSpecifierPublic)
	uint8                                         Pad_32[0xE];                                       // 0x0032(0x000E)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"InputDeviceTriggerEffect">();
	}
	static class UInputDeviceTriggerEffect* GetDefaultObj()
	{
		return GetDefaultObjImpl<UInputDeviceTriggerEffect>();
	}
};
static_assert(alignof(UInputDeviceTriggerEffect) == 0x000008, "Wrong alignment on UInputDeviceTriggerEffect");
static_assert(sizeof(UInputDeviceTriggerEffect) == 0x000040, "Wrong size on UInputDeviceTriggerEffect");
static_assert(offsetof(UInputDeviceTriggerEffect, BaseTriggerData) == 0x000030, "Member 'UInputDeviceTriggerEffect::BaseTriggerData' has a wrong offset!");

// Class Engine.ParticleModuleBeamBase
// 0x0000 (0x0030 - 0x0030)
class UParticleModuleBeamBase : public UParticleModule
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ParticleModuleBeamBase">();
	}
	static class UParticleModuleBeamBase* GetDefaultObj()
	{
		return GetDefaultObjImpl<UParticleModuleBeamBase>();
	}
};
static_assert(alignof(UParticleModuleBeamBase) == 0x000008, "Wrong alignment on UParticleModuleBeamBase");
static_assert(sizeof(UParticleModuleBeamBase) == 0x000030, "Wrong size on UParticleModuleBeamBase");

// Class Engine.ParticleModuleBeamSource
// 0x0118 (0x0148 - 0x0030)
class UParticleModuleBeamSource final : public UParticleModuleBeamBase
{
public:
	EBeam2SourceTargetMethod                      SourceMethod;                                      // 0x0030(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_31[0x3];                                       // 0x0031(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	class FName                                   SourceName;                                        // 0x0034(0x0008)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bSourceAbsolute : 1;                               // 0x003C(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_3D[0x3];                                       // 0x003D(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	struct FRawDistributionVector                 Source;                                            // 0x0040(0x0060)(Edit, ContainsInstancedReference, NativeAccessSpecifierPublic)
	uint8                                         bLockSource : 1;                                   // 0x00A0(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_A1[0x3];                                       // 0x00A1(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	EBeam2SourceTargetTangentMethod               SourceTangentMethod;                               // 0x00A4(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_A5[0x3];                                       // 0x00A5(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	struct FRawDistributionVector                 SourceTangent;                                     // 0x00A8(0x0060)(Edit, ContainsInstancedReference, NativeAccessSpecifierPublic)
	uint8                                         bLockSourceTangent : 1;                            // 0x0108(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_109[0x7];                                      // 0x0109(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	struct FRawDistributionFloat                  SourceStrength;                                    // 0x0110(0x0030)(Edit, ContainsInstancedReference, NativeAccessSpecifierPublic)
	uint8                                         bLockSourceStength : 1;                            // 0x0140(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_141[0x7];                                      // 0x0141(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ParticleModuleBeamSource">();
	}
	static class UParticleModuleBeamSource* GetDefaultObj()
	{
		return GetDefaultObjImpl<UParticleModuleBeamSource>();
	}
};
static_assert(alignof(UParticleModuleBeamSource) == 0x000008, "Wrong alignment on UParticleModuleBeamSource");
static_assert(sizeof(UParticleModuleBeamSource) == 0x000148, "Wrong size on UParticleModuleBeamSource");
static_assert(offsetof(UParticleModuleBeamSource, SourceMethod) == 0x000030, "Member 'UParticleModuleBeamSource::SourceMethod' has a wrong offset!");
static_assert(offsetof(UParticleModuleBeamSource, SourceName) == 0x000034, "Member 'UParticleModuleBeamSource::SourceName' has a wrong offset!");
static_assert(offsetof(UParticleModuleBeamSource, Source) == 0x000040, "Member 'UParticleModuleBeamSource::Source' has a wrong offset!");
static_assert(offsetof(UParticleModuleBeamSource, SourceTangentMethod) == 0x0000A4, "Member 'UParticleModuleBeamSource::SourceTangentMethod' has a wrong offset!");
static_assert(offsetof(UParticleModuleBeamSource, SourceTangent) == 0x0000A8, "Member 'UParticleModuleBeamSource::SourceTangent' has a wrong offset!");
static_assert(offsetof(UParticleModuleBeamSource, SourceStrength) == 0x000110, "Member 'UParticleModuleBeamSource::SourceStrength' has a wrong offset!");

// Class Engine.MaterialExpressionSkyAtmosphereViewLuminance
// 0x0000 (0x00B0 - 0x00B0)
class UMaterialExpressionSkyAtmosphereViewLuminance final : public UMaterialExpression
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionSkyAtmosphereViewLuminance">();
	}
	static class UMaterialExpressionSkyAtmosphereViewLuminance* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionSkyAtmosphereViewLuminance>();
	}
};
static_assert(alignof(UMaterialExpressionSkyAtmosphereViewLuminance) == 0x000008, "Wrong alignment on UMaterialExpressionSkyAtmosphereViewLuminance");
static_assert(sizeof(UMaterialExpressionSkyAtmosphereViewLuminance) == 0x0000B0, "Wrong size on UMaterialExpressionSkyAtmosphereViewLuminance");

// Class Engine.StaticMeshActor
// 0x0010 (0x02B0 - 0x02A0)
class AStaticMeshActor : public AActor
{
public:
	class UStaticMeshComponent*                   StaticMeshComponent;                               // 0x02A0(0x0008)(Edit, BlueprintVisible, ExportObject, BlueprintReadOnly, ZeroConstructor, EditConst, InstancedReference, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	bool                                          bStaticMeshReplicateMovement;                      // 0x02A8(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EPhysicsReplicationMode                       StaticMeshPhysicsReplicationMode;                  // 0x02A9(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	ENavDataGatheringMode                         NavigationGeometryGatheringMode;                   // 0x02AA(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_2AB[0x5];                                      // 0x02AB(0x0005)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void SetMobility(EComponentMobility InMobility);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"StaticMeshActor">();
	}
	static class AStaticMeshActor* GetDefaultObj()
	{
		return GetDefaultObjImpl<AStaticMeshActor>();
	}
};
static_assert(alignof(AStaticMeshActor) == 0x000008, "Wrong alignment on AStaticMeshActor");
static_assert(sizeof(AStaticMeshActor) == 0x0002B0, "Wrong size on AStaticMeshActor");
static_assert(offsetof(AStaticMeshActor, StaticMeshComponent) == 0x0002A0, "Member 'AStaticMeshActor::StaticMeshComponent' has a wrong offset!");
static_assert(offsetof(AStaticMeshActor, bStaticMeshReplicateMovement) == 0x0002A8, "Member 'AStaticMeshActor::bStaticMeshReplicateMovement' has a wrong offset!");
static_assert(offsetof(AStaticMeshActor, StaticMeshPhysicsReplicationMode) == 0x0002A9, "Member 'AStaticMeshActor::StaticMeshPhysicsReplicationMode' has a wrong offset!");
static_assert(offsetof(AStaticMeshActor, NavigationGeometryGatheringMode) == 0x0002AA, "Member 'AStaticMeshActor::NavigationGeometryGatheringMode' has a wrong offset!");

// Class Engine.PlayerStateCountLimiterConfig
// 0x0000 (0x0040 - 0x0040)
class UPlayerStateCountLimiterConfig final : public UNetObjectCountLimiterConfig
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"PlayerStateCountLimiterConfig">();
	}
	static class UPlayerStateCountLimiterConfig* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPlayerStateCountLimiterConfig>();
	}
};
static_assert(alignof(UPlayerStateCountLimiterConfig) == 0x000008, "Wrong alignment on UPlayerStateCountLimiterConfig");
static_assert(sizeof(UPlayerStateCountLimiterConfig) == 0x000040, "Wrong size on UPlayerStateCountLimiterConfig");

// Class Engine.CameraComponent
// 0x07A0 (0x0A40 - 0x02A0)
#pragma pack(push, 0x1)
class alignas(0x10) UCameraComponent : public USceneComponent
{
public:
	float                                         FieldOfView;                                       // 0x02A0(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         OrthoWidth;                                        // 0x02A4(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         OrthoNearClipPlane;                                // 0x02A8(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         OrthoFarClipPlane;                                 // 0x02AC(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         AspectRatio;                                       // 0x02B0(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EAspectRatioAxisConstraint                    AspectRatioAxisConstraint;                         // 0x02B4(0x0001)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bConstrainAspectRatio : 1;                         // 0x02B5(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, BlueprintVisible, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bOverrideAspectRatioAxisConstraint : 1;            // 0x02B5(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, BlueprintVisible, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bUseFieldOfViewForLOD : 1;                         // 0x02B5(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Edit, BlueprintVisible, Interp, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bLockToHmd : 1;                                    // 0x02B5(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bUsePawnControlRotation : 1;                       // 0x02B5(0x0001)(BitIndex: 0x04, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	ECameraProjectionMode                         ProjectionMode;                                    // 0x02B6(0x0001)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_2B7[0x69];                                     // 0x02B7(0x0069)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         PostProcessBlendWeight;                            // 0x0320(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_324[0x2C];                                     // 0x0324(0x002C)(Fixing Size After Last Property [ Dumper-7 ])
	struct FPostProcessSettings                   PostProcessSettings;                               // 0x0350(0x06E0)(Edit, BlueprintVisible, Interp, NativeAccessSpecifierPublic)
	uint8                                         bIsDisableMFSR : 1;                                // 0x0A30(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_A31[0x7];                                      // 0x0A31(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void AddOrUpdateBlendable(TScriptInterface<class IBlendableInterface> InBlendableObject, float InWeight);
	void GetCameraView(float DeltaTime, struct FMinimalViewInfo* DesiredView);
	void OnCameraMeshHiddenChanged();
	void RemoveBlendable(TScriptInterface<class IBlendableInterface> InBlendableObject);
	void SetAspectRatio(float InAspectRatio);
	void SetAspectRatioAxisConstraint(EAspectRatioAxisConstraint InAspectRatioAxisConstraint);
	void SetConstraintAspectRatio(bool bInConstrainAspectRatio);
	void SetFieldOfView(float InFieldOfView);
	void SetOrthoFarClipPlane(float InOrthoFarClipPlane);
	void SetOrthoNearClipPlane(float InOrthoNearClipPlane);
	void SetOrthoWidth(float InOrthoWidth);
	void SetPostProcessBlendWeight(float InPostProcessBlendWeight);
	void SetProjectionMode(ECameraProjectionMode InProjectionMode);
	void SetUseFieldOfViewForLOD(bool bInUseFieldOfViewForLOD);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"CameraComponent">();
	}
	static class UCameraComponent* GetDefaultObj()
	{
		return GetDefaultObjImpl<UCameraComponent>();
	}
};
#pragma pack(pop)
static_assert(alignof(UCameraComponent) == 0x000010, "Wrong alignment on UCameraComponent");
static_assert(sizeof(UCameraComponent) == 0x000A40, "Wrong size on UCameraComponent");
static_assert(offsetof(UCameraComponent, FieldOfView) == 0x0002A0, "Member 'UCameraComponent::FieldOfView' has a wrong offset!");
static_assert(offsetof(UCameraComponent, OrthoWidth) == 0x0002A4, "Member 'UCameraComponent::OrthoWidth' has a wrong offset!");
static_assert(offsetof(UCameraComponent, OrthoNearClipPlane) == 0x0002A8, "Member 'UCameraComponent::OrthoNearClipPlane' has a wrong offset!");
static_assert(offsetof(UCameraComponent, OrthoFarClipPlane) == 0x0002AC, "Member 'UCameraComponent::OrthoFarClipPlane' has a wrong offset!");
static_assert(offsetof(UCameraComponent, AspectRatio) == 0x0002B0, "Member 'UCameraComponent::AspectRatio' has a wrong offset!");
static_assert(offsetof(UCameraComponent, AspectRatioAxisConstraint) == 0x0002B4, "Member 'UCameraComponent::AspectRatioAxisConstraint' has a wrong offset!");
static_assert(offsetof(UCameraComponent, ProjectionMode) == 0x0002B6, "Member 'UCameraComponent::ProjectionMode' has a wrong offset!");
static_assert(offsetof(UCameraComponent, PostProcessBlendWeight) == 0x000320, "Member 'UCameraComponent::PostProcessBlendWeight' has a wrong offset!");
static_assert(offsetof(UCameraComponent, PostProcessSettings) == 0x000350, "Member 'UCameraComponent::PostProcessSettings' has a wrong offset!");

// Class Engine.Brush
// 0x0038 (0x02D8 - 0x02A0)
class ABrush : public AActor
{
public:
	EBrushType                                    BrushType;                                         // 0x02A0(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_2A1[0x3];                                      // 0x02A1(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	struct FColor                                 BrushColor;                                        // 0x02A4(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         PolyFlags;                                         // 0x02A8(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bColored : 1;                                      // 0x02AC(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bSolidWhenSelected : 1;                            // 0x02AC(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bPlaceableFromClassBrowser : 1;                    // 0x02AC(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bNotForClientOrServer : 1;                         // 0x02AC(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_2AD[0x3];                                      // 0x02AD(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	class UModel*                                 Brush;                                             // 0x02B0(0x0008)(ExportObject, ZeroConstructor, InstancedReference, NoDestructor, PersistentInstance, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UBrushComponent*                        BrushComponent;                                    // 0x02B8(0x0008)(Edit, BlueprintVisible, ExportObject, BlueprintReadOnly, ZeroConstructor, EditConst, InstancedReference, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         bInManipulation : 1;                               // 0x02C0(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_2C1[0x7];                                      // 0x02C1(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<struct FGeomSelection>                 SavedSelections;                                   // 0x02C8(0x0010)(ZeroConstructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"Brush">();
	}
	static class ABrush* GetDefaultObj()
	{
		return GetDefaultObjImpl<ABrush>();
	}
};
static_assert(alignof(ABrush) == 0x000008, "Wrong alignment on ABrush");
static_assert(sizeof(ABrush) == 0x0002D8, "Wrong size on ABrush");
static_assert(offsetof(ABrush, BrushType) == 0x0002A0, "Member 'ABrush::BrushType' has a wrong offset!");
static_assert(offsetof(ABrush, BrushColor) == 0x0002A4, "Member 'ABrush::BrushColor' has a wrong offset!");
static_assert(offsetof(ABrush, PolyFlags) == 0x0002A8, "Member 'ABrush::PolyFlags' has a wrong offset!");
static_assert(offsetof(ABrush, Brush) == 0x0002B0, "Member 'ABrush::Brush' has a wrong offset!");
static_assert(offsetof(ABrush, BrushComponent) == 0x0002B8, "Member 'ABrush::BrushComponent' has a wrong offset!");
static_assert(offsetof(ABrush, SavedSelections) == 0x0002C8, "Member 'ABrush::SavedSelections' has a wrong offset!");

// Class Engine.MaterialExpressionTextureProperty
// 0x0030 (0x00E0 - 0x00B0)
class UMaterialExpressionTextureProperty final : public UMaterialExpression
{
public:
	struct FExpressionInput                       TextureObject;                                     // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	EMaterialExposedTextureProperty               Property;                                          // 0x00D8(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_D9[0x7];                                       // 0x00D9(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionTextureProperty">();
	}
	static class UMaterialExpressionTextureProperty* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionTextureProperty>();
	}
};
static_assert(alignof(UMaterialExpressionTextureProperty) == 0x000008, "Wrong alignment on UMaterialExpressionTextureProperty");
static_assert(sizeof(UMaterialExpressionTextureProperty) == 0x0000E0, "Wrong size on UMaterialExpressionTextureProperty");
static_assert(offsetof(UMaterialExpressionTextureProperty, TextureObject) == 0x0000B0, "Member 'UMaterialExpressionTextureProperty::TextureObject' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionTextureProperty, Property) == 0x0000D8, "Member 'UMaterialExpressionTextureProperty::Property' has a wrong offset!");

// Class Engine.Volume
// 0x0000 (0x02D8 - 0x02D8)
class AVolume : public ABrush
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"Volume">();
	}
	static class AVolume* GetDefaultObj()
	{
		return GetDefaultObjImpl<AVolume>();
	}
};
static_assert(alignof(AVolume) == 0x000008, "Wrong alignment on AVolume");
static_assert(sizeof(AVolume) == 0x0002D8, "Wrong size on AVolume");

// Class Engine.SoundWave
// 0x02C8 (0x0430 - 0x0168)
class USoundWave : public USoundBase
{
public:
	uint8                                         Pad_168[0x10];                                     // 0x0168(0x0010)(Fixing Size After Last Property [ Dumper-7 ])
	int32                                         CompressionQuality;                                // 0x0178(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, AssetRegistrySearchable, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	int32                                         StreamingPriority;                                 // 0x017C(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	ESoundwaveSampleRateSettings                  SampleRateQuality;                                 // 0x0180(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_181[0x1];                                      // 0x0181(0x0001)(Fixing Size After Last Property [ Dumper-7 ])
	ESoundGroup                                   SoundGroup;                                        // 0x0182(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bLooping : 1;                                      // 0x0183(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, AssetRegistrySearchable, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bStreaming : 1;                                    // 0x0183(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	ESoundAssetCompressionType                    SoundAssetCompressionType;                         // 0x0184(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         bSeekableStreaming : 1;                            // 0x0185(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate))
	uint8                                         bUseBinkAudio : 1;                                 // 0x0185(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate))
	uint8                                         Pad_186[0x1A];                                     // 0x0186(0x001A)(Fixing Size After Last Property [ Dumper-7 ])
	struct FSoundModulationDefaultRoutingSettings ModulationSettings;                                // 0x01A0(0x0168)(Edit, BlueprintVisible, NativeAccessSpecifierPublic)
	TArray<float>                                 FrequenciesToAnalyze;                              // 0x0308(0x0010)(Edit, ZeroConstructor, NativeAccessSpecifierPublic)
	TArray<struct FSoundWaveSpectralTimeData>     CookedSpectralTimeData;                            // 0x0318(0x0010)(ZeroConstructor, NativeAccessSpecifierPublic)
	TArray<struct FSoundWaveEnvelopeTimeData>     CookedEnvelopeTimeData;                            // 0x0328(0x0010)(ZeroConstructor, NativeAccessSpecifierPublic)
	int32                                         InitialChunkSize;                                  // 0x0338(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_33C[0x40];                                     // 0x033C(0x0040)(Fixing Size After Last Property [ Dumper-7 ])
	uint8                                         BitPad_37C_0 : 5;                                  // 0x037C(0x0001)(Fixing Bit-Field Size Between Bits [ Dumper-7 ])
	uint8                                         bMature : 1;                                       // 0x037C(0x0001)(BitIndex: 0x05, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, AssetRegistrySearchable, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bManualWordWrap : 1;                               // 0x037C(0x0001)(BitIndex: 0x06, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bSingleLine : 1;                                   // 0x037C(0x0001)(BitIndex: 0x07, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bIsAmbisonics : 1;                                 // 0x037D(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	ESoundWaveLoadingBehavior                     LoadingBehavior;                                   // 0x037E(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_37F[0x1];                                      // 0x037F(0x0001)(Fixing Size After Last Property [ Dumper-7 ])
	class FString                                 SpokenText;                                        // 0x0380(0x0010)(ZeroConstructor, Deprecated, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         SubtitlePriority;                                  // 0x0390(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         Volume;                                            // 0x0394(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         Pitch;                                             // 0x0398(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         NumChannels;                                       // 0x039C(0x0004)(Edit, ZeroConstructor, EditConst, IsPlainOldData, NoDestructor, AssetRegistrySearchable, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TArray<struct FSoundWaveCuePoint>             CuePoints;                                         // 0x03A0(0x0010)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, EditConst, NativeAccessSpecifierPublic)
	int32                                         SampleRate;                                        // 0x03B0(0x0004)(Edit, ZeroConstructor, EditConst, IsPlainOldData, NoDestructor, AssetRegistrySearchable, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_3B4[0xC];                                      // 0x03B4(0x000C)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<struct FSubtitleCue>                   Subtitles;                                         // 0x03C0(0x0010)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, NativeAccessSpecifierPublic)
	class UCurveTable*                            Curves;                                            // 0x03D0(0x0008)(Edit, ZeroConstructor, NoDestructor, AdvancedDisplay, Protected, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	class UCurveTable*                            InternalCurves;                                    // 0x03D8(0x0008)(ZeroConstructor, NoDestructor, Protected, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_3E0[0x50];                                     // 0x03E0(0x0050)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void SetSoundAssetCompressionType(ESoundAssetCompressionType InSoundAssetCompressionType, bool bMarkDirty);

	TArray<struct FSoundWaveCuePoint> GetCuePoints() const;
	TArray<struct FSoundWaveCuePoint> GetLoopRegions() const;
	ESoundAssetCompressionType GetSoundAssetCompressionType() const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"SoundWave">();
	}
	static class USoundWave* GetDefaultObj()
	{
		return GetDefaultObjImpl<USoundWave>();
	}
};
static_assert(alignof(USoundWave) == 0x000008, "Wrong alignment on USoundWave");
static_assert(sizeof(USoundWave) == 0x000430, "Wrong size on USoundWave");
static_assert(offsetof(USoundWave, CompressionQuality) == 0x000178, "Member 'USoundWave::CompressionQuality' has a wrong offset!");
static_assert(offsetof(USoundWave, StreamingPriority) == 0x00017C, "Member 'USoundWave::StreamingPriority' has a wrong offset!");
static_assert(offsetof(USoundWave, SampleRateQuality) == 0x000180, "Member 'USoundWave::SampleRateQuality' has a wrong offset!");
static_assert(offsetof(USoundWave, SoundGroup) == 0x000182, "Member 'USoundWave::SoundGroup' has a wrong offset!");
static_assert(offsetof(USoundWave, SoundAssetCompressionType) == 0x000184, "Member 'USoundWave::SoundAssetCompressionType' has a wrong offset!");
static_assert(offsetof(USoundWave, ModulationSettings) == 0x0001A0, "Member 'USoundWave::ModulationSettings' has a wrong offset!");
static_assert(offsetof(USoundWave, FrequenciesToAnalyze) == 0x000308, "Member 'USoundWave::FrequenciesToAnalyze' has a wrong offset!");
static_assert(offsetof(USoundWave, CookedSpectralTimeData) == 0x000318, "Member 'USoundWave::CookedSpectralTimeData' has a wrong offset!");
static_assert(offsetof(USoundWave, CookedEnvelopeTimeData) == 0x000328, "Member 'USoundWave::CookedEnvelopeTimeData' has a wrong offset!");
static_assert(offsetof(USoundWave, InitialChunkSize) == 0x000338, "Member 'USoundWave::InitialChunkSize' has a wrong offset!");
static_assert(offsetof(USoundWave, LoadingBehavior) == 0x00037E, "Member 'USoundWave::LoadingBehavior' has a wrong offset!");
static_assert(offsetof(USoundWave, SpokenText) == 0x000380, "Member 'USoundWave::SpokenText' has a wrong offset!");
static_assert(offsetof(USoundWave, SubtitlePriority) == 0x000390, "Member 'USoundWave::SubtitlePriority' has a wrong offset!");
static_assert(offsetof(USoundWave, Volume) == 0x000394, "Member 'USoundWave::Volume' has a wrong offset!");
static_assert(offsetof(USoundWave, Pitch) == 0x000398, "Member 'USoundWave::Pitch' has a wrong offset!");
static_assert(offsetof(USoundWave, NumChannels) == 0x00039C, "Member 'USoundWave::NumChannels' has a wrong offset!");
static_assert(offsetof(USoundWave, CuePoints) == 0x0003A0, "Member 'USoundWave::CuePoints' has a wrong offset!");
static_assert(offsetof(USoundWave, SampleRate) == 0x0003B0, "Member 'USoundWave::SampleRate' has a wrong offset!");
static_assert(offsetof(USoundWave, Subtitles) == 0x0003C0, "Member 'USoundWave::Subtitles' has a wrong offset!");
static_assert(offsetof(USoundWave, Curves) == 0x0003D0, "Member 'USoundWave::Curves' has a wrong offset!");
static_assert(offsetof(USoundWave, InternalCurves) == 0x0003D8, "Member 'USoundWave::InternalCurves' has a wrong offset!");

// Class Engine.SoundWaveProcedural
// 0x0050 (0x0480 - 0x0430)
class USoundWaveProcedural : public USoundWave
{
public:
	uint8                                         Pad_430[0x50];                                     // 0x0430(0x0050)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"SoundWaveProcedural">();
	}
	static class USoundWaveProcedural* GetDefaultObj()
	{
		return GetDefaultObjImpl<USoundWaveProcedural>();
	}
};
static_assert(alignof(USoundWaveProcedural) == 0x000008, "Wrong alignment on USoundWaveProcedural");
static_assert(sizeof(USoundWaveProcedural) == 0x000480, "Wrong size on USoundWaveProcedural");

// Class Engine.PostProcessComponent
// 0x0700 (0x09A0 - 0x02A0)
class UPostProcessComponent final : public USceneComponent
{
public:
	uint8                                         Pad_2A0[0x10];                                     // 0x02A0(0x0010)(Fixing Size After Last Property [ Dumper-7 ])
	struct FPostProcessSettings                   Settings;                                          // 0x02B0(0x06E0)(Edit, BlueprintVisible, Interp, NativeAccessSpecifierPublic)
	float                                         Priority;                                          // 0x0990(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         BlendRadius;                                       // 0x0994(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         BlendWeight;                                       // 0x0998(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bEnabled : 1;                                      // 0x099C(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bUnbound : 1;                                      // 0x099C(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_99D[0x3];                                      // 0x099D(0x0003)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void AddOrUpdateBlendable(TScriptInterface<class IBlendableInterface> InBlendableObject, float InWeight);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"PostProcessComponent">();
	}
	static class UPostProcessComponent* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPostProcessComponent>();
	}
};
static_assert(alignof(UPostProcessComponent) == 0x000010, "Wrong alignment on UPostProcessComponent");
static_assert(sizeof(UPostProcessComponent) == 0x0009A0, "Wrong size on UPostProcessComponent");
static_assert(offsetof(UPostProcessComponent, Settings) == 0x0002B0, "Member 'UPostProcessComponent::Settings' has a wrong offset!");
static_assert(offsetof(UPostProcessComponent, Priority) == 0x000990, "Member 'UPostProcessComponent::Priority' has a wrong offset!");
static_assert(offsetof(UPostProcessComponent, BlendRadius) == 0x000994, "Member 'UPostProcessComponent::BlendRadius' has a wrong offset!");
static_assert(offsetof(UPostProcessComponent, BlendWeight) == 0x000998, "Member 'UPostProcessComponent::BlendWeight' has a wrong offset!");

// Class Engine.ParticleModuleEventBase
// 0x0000 (0x0030 - 0x0030)
class UParticleModuleEventBase : public UParticleModule
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ParticleModuleEventBase">();
	}
	static class UParticleModuleEventBase* GetDefaultObj()
	{
		return GetDefaultObjImpl<UParticleModuleEventBase>();
	}
};
static_assert(alignof(UParticleModuleEventBase) == 0x000008, "Wrong alignment on UParticleModuleEventBase");
static_assert(sizeof(UParticleModuleEventBase) == 0x000030, "Wrong size on UParticleModuleEventBase");

// Class Engine.ParticleModuleEventReceiverBase
// 0x0010 (0x0040 - 0x0030)
class UParticleModuleEventReceiverBase : public UParticleModuleEventBase
{
public:
	EParticleEventType                            EventGeneratorType;                                // 0x0030(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_31[0x3];                                       // 0x0031(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	class FName                                   EventName;                                         // 0x0034(0x0008)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_3C[0x4];                                       // 0x003C(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ParticleModuleEventReceiverBase">();
	}
	static class UParticleModuleEventReceiverBase* GetDefaultObj()
	{
		return GetDefaultObjImpl<UParticleModuleEventReceiverBase>();
	}
};
static_assert(alignof(UParticleModuleEventReceiverBase) == 0x000008, "Wrong alignment on UParticleModuleEventReceiverBase");
static_assert(sizeof(UParticleModuleEventReceiverBase) == 0x000040, "Wrong size on UParticleModuleEventReceiverBase");
static_assert(offsetof(UParticleModuleEventReceiverBase, EventGeneratorType) == 0x000030, "Member 'UParticleModuleEventReceiverBase::EventGeneratorType' has a wrong offset!");
static_assert(offsetof(UParticleModuleEventReceiverBase, EventName) == 0x000034, "Member 'UParticleModuleEventReceiverBase::EventName' has a wrong offset!");

// Class Engine.MaterialExpressionPrecomputedAOMask
// 0x0000 (0x00B0 - 0x00B0)
class UMaterialExpressionPrecomputedAOMask final : public UMaterialExpression
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionPrecomputedAOMask">();
	}
	static class UMaterialExpressionPrecomputedAOMask* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionPrecomputedAOMask>();
	}
};
static_assert(alignof(UMaterialExpressionPrecomputedAOMask) == 0x000008, "Wrong alignment on UMaterialExpressionPrecomputedAOMask");
static_assert(sizeof(UMaterialExpressionPrecomputedAOMask) == 0x0000B0, "Wrong size on UMaterialExpressionPrecomputedAOMask");

// Class Engine.StreamableRenderAsset
// 0x00A0 (0x00C8 - 0x0028)
class UStreamableRenderAsset : public UObject
{
public:
	uint8                                         Pad_28[0x18];                                      // 0x0028(0x0018)(Fixing Size After Last Property [ Dumper-7 ])
	double                                        ForceMipLevelsToBeResidentTimestamp;               // 0x0040(0x0008)(ZeroConstructor, Transient, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	int32                                         NumCinematicMipLevels;                             // 0x0048(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_4C[0x4];                                       // 0x004C(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	struct FPerQualityLevelInt                    NoRefStreamingLODBias;                             // 0x0050(0x0068)(Protected, NativeAccessSpecifierProtected)
	int32                                         StreamingIndex;                                    // 0x00B8(0x0004)(ZeroConstructor, Transient, DuplicateTransient, IsPlainOldData, NonTransactional, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         NeverStream : 1;                                   // 0x00BC(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, AssetRegistrySearchable, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bGlobalForceMipLevelsToBeResident : 1;             // 0x00BC(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bHasStreamingUpdatePending : 1;                    // 0x00BC(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Transient, NonTransactional, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bForceMiplevelsToBeResident : 1;                   // 0x00BC(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (Transient, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bIgnoreStreamingMipBias : 1;                       // 0x00BC(0x0001)(BitIndex: 0x04, PropSize: 0x0001 (Transient, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bUseCinematicMipLevels : 1;                        // 0x00BC(0x0001)(BitIndex: 0x05, PropSize: 0x0001 (Transient, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
	uint8                                         Pad_BD[0xB];                                       // 0x00BD(0x000B)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void SetForceMipLevelsToBeResident(float Seconds, int32 CinematicLODGroupMask);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"StreamableRenderAsset">();
	}
	static class UStreamableRenderAsset* GetDefaultObj()
	{
		return GetDefaultObjImpl<UStreamableRenderAsset>();
	}
};
static_assert(alignof(UStreamableRenderAsset) == 0x000008, "Wrong alignment on UStreamableRenderAsset");
static_assert(sizeof(UStreamableRenderAsset) == 0x0000C8, "Wrong size on UStreamableRenderAsset");
static_assert(offsetof(UStreamableRenderAsset, ForceMipLevelsToBeResidentTimestamp) == 0x000040, "Member 'UStreamableRenderAsset::ForceMipLevelsToBeResidentTimestamp' has a wrong offset!");
static_assert(offsetof(UStreamableRenderAsset, NumCinematicMipLevels) == 0x000048, "Member 'UStreamableRenderAsset::NumCinematicMipLevels' has a wrong offset!");
static_assert(offsetof(UStreamableRenderAsset, NoRefStreamingLODBias) == 0x000050, "Member 'UStreamableRenderAsset::NoRefStreamingLODBias' has a wrong offset!");
static_assert(offsetof(UStreamableRenderAsset, StreamingIndex) == 0x0000B8, "Member 'UStreamableRenderAsset::StreamingIndex' has a wrong offset!");

// Class Engine.MaterialFunction
// 0x0028 (0x0068 - 0x0040)
class UMaterialFunction : public UMaterialFunctionInterface
{
public:
	class FString                                 Description;                                       // 0x0040(0x0010)(Edit, ZeroConstructor, AssetRegistrySearchable, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FString                                 UserExposedCaption;                                // 0x0050(0x0010)(Edit, ZeroConstructor, AssetRegistrySearchable, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bExposeToLibrary : 1;                              // 0x0060(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, AssetRegistrySearchable, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bPrefixParameterNames : 1;                         // 0x0060(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bEnableExecWire : 1;                               // 0x0060(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bEnableNewHLSLGenerator : 1;                       // 0x0060(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_61[0x7];                                       // 0x0061(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialFunction">();
	}
	static class UMaterialFunction* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialFunction>();
	}
};
static_assert(alignof(UMaterialFunction) == 0x000008, "Wrong alignment on UMaterialFunction");
static_assert(sizeof(UMaterialFunction) == 0x000068, "Wrong size on UMaterialFunction");
static_assert(offsetof(UMaterialFunction, Description) == 0x000040, "Member 'UMaterialFunction::Description' has a wrong offset!");
static_assert(offsetof(UMaterialFunction, UserExposedCaption) == 0x000050, "Member 'UMaterialFunction::UserExposedCaption' has a wrong offset!");

// Class Engine.DecalActor
// 0x0008 (0x02A8 - 0x02A0)
class ADecalActor : public AActor
{
public:
	class UDecalComponent*                        Decal;                                             // 0x02A0(0x0008)(Edit, BlueprintVisible, ExportObject, BlueprintReadOnly, ZeroConstructor, EditConst, InstancedReference, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)

public:
	class UMaterialInstanceDynamic* CreateDynamicMaterialInstance();
	void SetDecalMaterial(class UMaterialInterface* NewDecalMaterial);

	class UMaterialInterface* GetDecalMaterial() const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"DecalActor">();
	}
	static class ADecalActor* GetDefaultObj()
	{
		return GetDefaultObjImpl<ADecalActor>();
	}
};
static_assert(alignof(ADecalActor) == 0x000008, "Wrong alignment on ADecalActor");
static_assert(sizeof(ADecalActor) == 0x0002A8, "Wrong size on ADecalActor");
static_assert(offsetof(ADecalActor, Decal) == 0x0002A0, "Member 'ADecalActor::Decal' has a wrong offset!");

// Class Engine.BlueprintCore
// 0x0028 (0x0050 - 0x0028)
class UBlueprintCore : public UObject
{
public:
	TSubclassOf<class UObject>                    SkeletonGeneratedClass;                            // 0x0028(0x0008)(ZeroConstructor, Transient, NonTransactional, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TSubclassOf<class UObject>                    GeneratedClass;                                    // 0x0030(0x0008)(ZeroConstructor, NonTransactional, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bLegacyNeedToPurgeSkelRefs;                        // 0x0038(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_39[0x3];                                       // 0x0039(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	struct FGuid                                  BlueprintGuid;                                     // 0x003C(0x0010)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_4C[0x4];                                       // 0x004C(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"BlueprintCore">();
	}
	static class UBlueprintCore* GetDefaultObj()
	{
		return GetDefaultObjImpl<UBlueprintCore>();
	}
};
static_assert(alignof(UBlueprintCore) == 0x000008, "Wrong alignment on UBlueprintCore");
static_assert(sizeof(UBlueprintCore) == 0x000050, "Wrong size on UBlueprintCore");
static_assert(offsetof(UBlueprintCore, SkeletonGeneratedClass) == 0x000028, "Member 'UBlueprintCore::SkeletonGeneratedClass' has a wrong offset!");
static_assert(offsetof(UBlueprintCore, GeneratedClass) == 0x000030, "Member 'UBlueprintCore::GeneratedClass' has a wrong offset!");
static_assert(offsetof(UBlueprintCore, bLegacyNeedToPurgeSkelRefs) == 0x000038, "Member 'UBlueprintCore::bLegacyNeedToPurgeSkelRefs' has a wrong offset!");
static_assert(offsetof(UBlueprintCore, BlueprintGuid) == 0x00003C, "Member 'UBlueprintCore::BlueprintGuid' has a wrong offset!");

// Class Engine.Blueprint
// 0x0058 (0x00A8 - 0x0050)
class UBlueprint : public UBlueprintCore
{
public:
	uint8                                         Pad_50[0x8];                                       // 0x0050(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	TSubclassOf<class UObject>                    ParentClass;                                       // 0x0058(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EBlueprintType                                BlueprintType;                                     // 0x0060(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, AssetRegistrySearchable, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bRecompileOnLoad : 1;                              // 0x0061(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bHasBeenRegenerated : 1;                           // 0x0061(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Transient, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bIsRegeneratingOnLoad : 1;                         // 0x0061(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Transient, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_62[0x2];                                       // 0x0062(0x0002)(Fixing Size After Last Property [ Dumper-7 ])
	int32                                         BlueprintSystemVersion;                            // 0x0064(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class USimpleConstructionScript*              SimpleConstructionScript;                          // 0x0068(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TArray<class UActorComponent*>                ComponentTemplates;                                // 0x0070(0x0010)(ExportObject, ZeroConstructor, ContainsInstancedReference, UObjectWrapper, NativeAccessSpecifierPublic)
	TArray<class UTimelineTemplate*>              Timelines;                                         // 0x0080(0x0010)(ZeroConstructor, UObjectWrapper, NativeAccessSpecifierPublic)
	TArray<struct FBPComponentClassOverride>      ComponentClassOverrides;                           // 0x0090(0x0010)(ZeroConstructor, NativeAccessSpecifierPublic)
	class UInheritableComponentHandler*           InheritableComponentHandler;                       // 0x00A0(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"Blueprint">();
	}
	static class UBlueprint* GetDefaultObj()
	{
		return GetDefaultObjImpl<UBlueprint>();
	}
};
static_assert(alignof(UBlueprint) == 0x000008, "Wrong alignment on UBlueprint");
static_assert(sizeof(UBlueprint) == 0x0000A8, "Wrong size on UBlueprint");
static_assert(offsetof(UBlueprint, ParentClass) == 0x000058, "Member 'UBlueprint::ParentClass' has a wrong offset!");
static_assert(offsetof(UBlueprint, BlueprintType) == 0x000060, "Member 'UBlueprint::BlueprintType' has a wrong offset!");
static_assert(offsetof(UBlueprint, BlueprintSystemVersion) == 0x000064, "Member 'UBlueprint::BlueprintSystemVersion' has a wrong offset!");
static_assert(offsetof(UBlueprint, SimpleConstructionScript) == 0x000068, "Member 'UBlueprint::SimpleConstructionScript' has a wrong offset!");
static_assert(offsetof(UBlueprint, ComponentTemplates) == 0x000070, "Member 'UBlueprint::ComponentTemplates' has a wrong offset!");
static_assert(offsetof(UBlueprint, Timelines) == 0x000080, "Member 'UBlueprint::Timelines' has a wrong offset!");
static_assert(offsetof(UBlueprint, ComponentClassOverrides) == 0x000090, "Member 'UBlueprint::ComponentClassOverrides' has a wrong offset!");
static_assert(offsetof(UBlueprint, InheritableComponentHandler) == 0x0000A0, "Member 'UBlueprint::InheritableComponentHandler' has a wrong offset!");

// Class Engine.MaterialExpressionSkyAtmosphereLightDirection
// 0x0008 (0x00B8 - 0x00B0)
class UMaterialExpressionSkyAtmosphereLightDirection final : public UMaterialExpression
{
public:
	int32                                         LightIndex;                                        // 0x00B0(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_B4[0x4];                                       // 0x00B4(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionSkyAtmosphereLightDirection">();
	}
	static class UMaterialExpressionSkyAtmosphereLightDirection* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionSkyAtmosphereLightDirection>();
	}
};
static_assert(alignof(UMaterialExpressionSkyAtmosphereLightDirection) == 0x000008, "Wrong alignment on UMaterialExpressionSkyAtmosphereLightDirection");
static_assert(sizeof(UMaterialExpressionSkyAtmosphereLightDirection) == 0x0000B8, "Wrong size on UMaterialExpressionSkyAtmosphereLightDirection");
static_assert(offsetof(UMaterialExpressionSkyAtmosphereLightDirection, LightIndex) == 0x0000B0, "Member 'UMaterialExpressionSkyAtmosphereLightDirection::LightIndex' has a wrong offset!");

// Class Engine.LightWeightInstanceManager
// 0x00B0 (0x0350 - 0x02A0)
class ALightWeightInstanceManager : public AActor
{
public:
	uint8                                         Pad_2A0[0x10];                                     // 0x02A0(0x0010)(Fixing Size After Last Property [ Dumper-7 ])
	TSubclassOf<class AActor>                     RepresentedClass;                                  // 0x02B0(0x0008)(Edit, Net, ZeroConstructor, DisableEditOnInstance, NoDestructor, Protected, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	TSubclassOf<class AActor>                     AcceptedClass;                                     // 0x02B8(0x0008)(ZeroConstructor, NoDestructor, Protected, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	TArray<struct FTransform>                     InstanceTransforms;                                // 0x02C0(0x0010)(Edit, Net, ZeroConstructor, DisableEditOnTemplate, RepNotify, Protected, NativeAccessSpecifierProtected)
	TMap<int32, class AActor*>                    Actors;                                            // 0x02D0(0x0050)(Transient, Protected, UObjectWrapper, NativeAccessSpecifierProtected)
	uint8                                         Pad_320[0x10];                                     // 0x0320(0x0010)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<int32>                                 FreeIndices;                                       // 0x0330(0x0010)(Net, ZeroConstructor, Protected, NativeAccessSpecifierProtected)
	TArray<bool>                                  ValidIndices;                                      // 0x0340(0x0010)(Net, ZeroConstructor, Protected, NativeAccessSpecifierProtected)

public:
	void OnRep_Transforms();
	void OnSpawnedActorDestroyed(class AActor* DestroyedActor);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"LightWeightInstanceManager">();
	}
	static class ALightWeightInstanceManager* GetDefaultObj()
	{
		return GetDefaultObjImpl<ALightWeightInstanceManager>();
	}
};
static_assert(alignof(ALightWeightInstanceManager) == 0x000008, "Wrong alignment on ALightWeightInstanceManager");
static_assert(sizeof(ALightWeightInstanceManager) == 0x000350, "Wrong size on ALightWeightInstanceManager");
static_assert(offsetof(ALightWeightInstanceManager, RepresentedClass) == 0x0002B0, "Member 'ALightWeightInstanceManager::RepresentedClass' has a wrong offset!");
static_assert(offsetof(ALightWeightInstanceManager, AcceptedClass) == 0x0002B8, "Member 'ALightWeightInstanceManager::AcceptedClass' has a wrong offset!");
static_assert(offsetof(ALightWeightInstanceManager, InstanceTransforms) == 0x0002C0, "Member 'ALightWeightInstanceManager::InstanceTransforms' has a wrong offset!");
static_assert(offsetof(ALightWeightInstanceManager, Actors) == 0x0002D0, "Member 'ALightWeightInstanceManager::Actors' has a wrong offset!");
static_assert(offsetof(ALightWeightInstanceManager, FreeIndices) == 0x000330, "Member 'ALightWeightInstanceManager::FreeIndices' has a wrong offset!");
static_assert(offsetof(ALightWeightInstanceManager, ValidIndices) == 0x000340, "Member 'ALightWeightInstanceManager::ValidIndices' has a wrong offset!");

// Class Engine.LightWeightInstanceStaticMeshManager
// 0x0068 (0x03B8 - 0x0350)
class ALightWeightInstanceStaticMeshManager final : public ALightWeightInstanceManager
{
public:
	uint8                                         Pad_350[0x8];                                      // 0x0350(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	TSoftObjectPtr<class UStaticMesh>             StaticMesh;                                        // 0x0358(0x0028)(Edit, BlueprintVisible, BlueprintReadOnly, Net, DisableEditOnTemplate, RepNotify, Protected, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	class UHierarchicalInstancedStaticMeshComponent* InstancedStaticMeshComponent;                   // 0x0380(0x0008)(Edit, BlueprintVisible, ExportObject, BlueprintReadOnly, ZeroConstructor, InstancedReference, NoDestructor, AdvancedDisplay, Protected, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	TArray<int32>                                 RenderingIndicesToDataIndices;                     // 0x0388(0x0010)(Net, ZeroConstructor, Protected, NativeAccessSpecifierProtected)
	TArray<int32>                                 DataIndicesToRenderingIndices;                     // 0x0398(0x0010)(Net, ZeroConstructor, Protected, NativeAccessSpecifierProtected)
	uint8                                         Pad_3A8[0x10];                                     // 0x03A8(0x0010)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void OnRep_StaticMesh();

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"LightWeightInstanceStaticMeshManager">();
	}
	static class ALightWeightInstanceStaticMeshManager* GetDefaultObj()
	{
		return GetDefaultObjImpl<ALightWeightInstanceStaticMeshManager>();
	}
};
static_assert(alignof(ALightWeightInstanceStaticMeshManager) == 0x000008, "Wrong alignment on ALightWeightInstanceStaticMeshManager");
static_assert(sizeof(ALightWeightInstanceStaticMeshManager) == 0x0003B8, "Wrong size on ALightWeightInstanceStaticMeshManager");
static_assert(offsetof(ALightWeightInstanceStaticMeshManager, StaticMesh) == 0x000358, "Member 'ALightWeightInstanceStaticMeshManager::StaticMesh' has a wrong offset!");
static_assert(offsetof(ALightWeightInstanceStaticMeshManager, InstancedStaticMeshComponent) == 0x000380, "Member 'ALightWeightInstanceStaticMeshManager::InstancedStaticMeshComponent' has a wrong offset!");
static_assert(offsetof(ALightWeightInstanceStaticMeshManager, RenderingIndicesToDataIndices) == 0x000388, "Member 'ALightWeightInstanceStaticMeshManager::RenderingIndicesToDataIndices' has a wrong offset!");
static_assert(offsetof(ALightWeightInstanceStaticMeshManager, DataIndicesToRenderingIndices) == 0x000398, "Member 'ALightWeightInstanceStaticMeshManager::DataIndicesToRenderingIndices' has a wrong offset!");

// Class Engine.SoundEffectPreset
// 0x0040 (0x0068 - 0x0028)
class USoundEffectPreset : public UObject
{
public:
	uint8                                         Pad_28[0x40];                                      // 0x0028(0x0040)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"SoundEffectPreset">();
	}
	static class USoundEffectPreset* GetDefaultObj()
	{
		return GetDefaultObjImpl<USoundEffectPreset>();
	}
};
static_assert(alignof(USoundEffectPreset) == 0x000008, "Wrong alignment on USoundEffectPreset");
static_assert(sizeof(USoundEffectPreset) == 0x000068, "Wrong size on USoundEffectPreset");

// Class Engine.SaveGame
// 0x0000 (0x0028 - 0x0028)
class USaveGame : public UObject
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"SaveGame">();
	}
	static class USaveGame* GetDefaultObj()
	{
		return GetDefaultObjImpl<USaveGame>();
	}
};
static_assert(alignof(USaveGame) == 0x000008, "Wrong alignment on USaveGame");
static_assert(sizeof(USaveGame) == 0x000028, "Wrong size on USaveGame");

// Class Engine.MaterialInstanceConstant
// 0x0008 (0x0250 - 0x0248)
class UMaterialInstanceConstant : public UMaterialInstance
{
public:
	class UPhysicalMaterialMask*                  PhysMaterialMask;                                  // 0x0248(0x0008)(Edit, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)

public:
	float K2_GetScalarParameterValue(class FName ParameterName);
	class UTexture* K2_GetTextureParameterValue(class FName ParameterName);
	struct FLinearColor K2_GetVectorParameterValue(class FName ParameterName);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialInstanceConstant">();
	}
	static class UMaterialInstanceConstant* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialInstanceConstant>();
	}
};
static_assert(alignof(UMaterialInstanceConstant) == 0x000008, "Wrong alignment on UMaterialInstanceConstant");
static_assert(sizeof(UMaterialInstanceConstant) == 0x000250, "Wrong size on UMaterialInstanceConstant");
static_assert(offsetof(UMaterialInstanceConstant, PhysMaterialMask) == 0x000248, "Member 'UMaterialInstanceConstant::PhysMaterialMask' has a wrong offset!");

// Class Engine.MaterialFunctionMaterialLayerBlendInstance
// 0x0000 (0x00E0 - 0x00E0)
class UMaterialFunctionMaterialLayerBlendInstance final : public UMaterialFunctionInstance
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialFunctionMaterialLayerBlendInstance">();
	}
	static class UMaterialFunctionMaterialLayerBlendInstance* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialFunctionMaterialLayerBlendInstance>();
	}
};
static_assert(alignof(UMaterialFunctionMaterialLayerBlendInstance) == 0x000008, "Wrong alignment on UMaterialFunctionMaterialLayerBlendInstance");
static_assert(sizeof(UMaterialFunctionMaterialLayerBlendInstance) == 0x0000E0, "Wrong size on UMaterialFunctionMaterialLayerBlendInstance");

// Class Engine.MaterialExpressionRayTracingQualitySwitch
// 0x0050 (0x0100 - 0x00B0)
class UMaterialExpressionRayTracingQualitySwitch final : public UMaterialExpression
{
public:
	struct FExpressionInput                       Normal;                                            // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       RayTraced;                                         // 0x00D8(0x0028)(NoDestructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionRayTracingQualitySwitch">();
	}
	static class UMaterialExpressionRayTracingQualitySwitch* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionRayTracingQualitySwitch>();
	}
};
static_assert(alignof(UMaterialExpressionRayTracingQualitySwitch) == 0x000008, "Wrong alignment on UMaterialExpressionRayTracingQualitySwitch");
static_assert(sizeof(UMaterialExpressionRayTracingQualitySwitch) == 0x000100, "Wrong size on UMaterialExpressionRayTracingQualitySwitch");
static_assert(offsetof(UMaterialExpressionRayTracingQualitySwitch, Normal) == 0x0000B0, "Member 'UMaterialExpressionRayTracingQualitySwitch::Normal' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionRayTracingQualitySwitch, RayTraced) == 0x0000D8, "Member 'UMaterialExpressionRayTracingQualitySwitch::RayTraced' has a wrong offset!");

// Class Engine.AsyncPhysicsInputComponent
// 0x0028 (0x00D0 - 0x00A8)
class UAsyncPhysicsInputComponent final : public UActorComponent
{
public:
	TSubclassOf<class UAsyncPhysicsData>          DataClass;                                         // 0x00A8(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	TArray<class UAsyncPhysicsData*>              BufferedData;                                      // 0x00B0(0x0010)(ZeroConstructor, Transient, UObjectWrapper, NativeAccessSpecifierPrivate)
	class UAsyncPhysicsData*                      DataToConsume;                                     // 0x00C0(0x0008)(ZeroConstructor, Transient, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	class UAsyncPhysicsData*                      DataToWrite;                                       // 0x00C8(0x0008)(ZeroConstructor, Transient, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)

public:
	void ServerRPCBufferInput(class UAsyncPhysicsData* AsyncPhysicsData);

	const class UAsyncPhysicsData* GetDataToConsume() const;
	class UAsyncPhysicsData* GetDataToWrite() const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AsyncPhysicsInputComponent">();
	}
	static class UAsyncPhysicsInputComponent* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAsyncPhysicsInputComponent>();
	}
};
static_assert(alignof(UAsyncPhysicsInputComponent) == 0x000008, "Wrong alignment on UAsyncPhysicsInputComponent");
static_assert(sizeof(UAsyncPhysicsInputComponent) == 0x0000D0, "Wrong size on UAsyncPhysicsInputComponent");
static_assert(offsetof(UAsyncPhysicsInputComponent, DataClass) == 0x0000A8, "Member 'UAsyncPhysicsInputComponent::DataClass' has a wrong offset!");
static_assert(offsetof(UAsyncPhysicsInputComponent, BufferedData) == 0x0000B0, "Member 'UAsyncPhysicsInputComponent::BufferedData' has a wrong offset!");
static_assert(offsetof(UAsyncPhysicsInputComponent, DataToConsume) == 0x0000C0, "Member 'UAsyncPhysicsInputComponent::DataToConsume' has a wrong offset!");
static_assert(offsetof(UAsyncPhysicsInputComponent, DataToWrite) == 0x0000C8, "Member 'UAsyncPhysicsInputComponent::DataToWrite' has a wrong offset!");

// Class Engine.MaterialExpressionRerouteBase
// 0x0000 (0x00B0 - 0x00B0)
class UMaterialExpressionRerouteBase : public UMaterialExpression
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionRerouteBase">();
	}
	static class UMaterialExpressionRerouteBase* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionRerouteBase>();
	}
};
static_assert(alignof(UMaterialExpressionRerouteBase) == 0x000008, "Wrong alignment on UMaterialExpressionRerouteBase");
static_assert(sizeof(UMaterialExpressionRerouteBase) == 0x0000B0, "Wrong size on UMaterialExpressionRerouteBase");

// Class Engine.MaterialExpressionReroute
// 0x0028 (0x00D8 - 0x00B0)
class UMaterialExpressionReroute final : public UMaterialExpressionRerouteBase
{
public:
	struct FExpressionInput                       Input;                                             // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionReroute">();
	}
	static class UMaterialExpressionReroute* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionReroute>();
	}
};
static_assert(alignof(UMaterialExpressionReroute) == 0x000008, "Wrong alignment on UMaterialExpressionReroute");
static_assert(sizeof(UMaterialExpressionReroute) == 0x0000D8, "Wrong size on UMaterialExpressionReroute");
static_assert(offsetof(UMaterialExpressionReroute, Input) == 0x0000B0, "Member 'UMaterialExpressionReroute::Input' has a wrong offset!");

// Class Engine.AnimLayerInterface
// 0x0000 (0x0000 - 0x0000)
class IAnimLayerInterface final
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AnimLayerInterface">();
	}
	static class IAnimLayerInterface* GetDefaultObj()
	{
		return GetDefaultObjImpl<IAnimLayerInterface>();
	}

	class UObject* AsUObject()
	{
		return reinterpret_cast<UObject*>(this);
	}
	const class UObject* AsUObject() const
	{
		return reinterpret_cast<const UObject*>(this);
	}
};
static_assert(alignof(IAnimLayerInterface) == 0x000001, "Wrong alignment on IAnimLayerInterface");
static_assert(sizeof(IAnimLayerInterface) == 0x000001, "Wrong size on IAnimLayerInterface");

// Class Engine.Pawn
// 0x0088 (0x0328 - 0x02A0)
class APawn : public AActor
{
public:
	uint8                                         Pad_2A0[0x8];                                      // 0x02A0(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	uint8                                         bUseControllerRotationPitch : 1;                   // 0x02A8(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bUseControllerRotationYaw : 1;                     // 0x02A8(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bUseControllerRotationRoll : 1;                    // 0x02A8(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bCanAffectNavigationGeneration : 1;                // 0x02A8(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         BitPad_2A8_4 : 2;                                  // 0x02A8(0x0001)(Fixing Bit-Field Size Between Bits [ Dumper-7 ])
	uint8                                         bIsLocalViewTarget : 1;                            // 0x02A8(0x0001)(BitIndex: 0x06, PropSize: 0x0001 (Transient, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
	uint8                                         Pad_2A9[0x3];                                      // 0x02A9(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         BaseEyeHeight;                                     // 0x02AC(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EAutoReceiveInput                             AutoPossessPlayer;                                 // 0x02B0(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EAutoPossessAI                                AutoPossessAI;                                     // 0x02B1(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         RemoteViewPitch;                                   // 0x02B2(0x0001)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_2B3[0x5];                                      // 0x02B3(0x0005)(Fixing Size After Last Property [ Dumper-7 ])
	TSubclassOf<class AController>                AIControllerClass;                                 // 0x02B8(0x0008)(Edit, BlueprintVisible, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class APlayerState*                           PlayerState;                                       // 0x02C0(0x0008)(BlueprintVisible, BlueprintReadOnly, Net, ZeroConstructor, RepNotify, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_2C8[0x8];                                      // 0x02C8(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	class AController*                            LastHitBy;                                         // 0x02D0(0x0008)(BlueprintVisible, BlueprintReadOnly, ZeroConstructor, Transient, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AController*                            Controller;                                        // 0x02D8(0x0008)(Net, ZeroConstructor, RepNotify, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AController*                            PreviousController;                                // 0x02E0(0x0008)(ZeroConstructor, Transient, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_2E8[0x4];                                      // 0x02E8(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	FMulticastSparseDelegateProperty_             ReceiveControllerChangedDelegate;                  // 0x02EC(0x0001)(InstancedReference, BlueprintAssignable, NoDestructor, NativeAccessSpecifierPublic)
	FMulticastSparseDelegateProperty_             ReceiveRestartedDelegate;                          // 0x02ED(0x0001)(InstancedReference, BlueprintAssignable, NoDestructor, NativeAccessSpecifierPublic)
	uint8                                         Pad_2EE[0x2];                                      // 0x02EE(0x0002)(Fixing Size After Last Property [ Dumper-7 ])
	struct FVector                                ControlInputVector;                                // 0x02F0(0x0018)(ZeroConstructor, Transient, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	struct FVector                                LastControlInputVector;                            // 0x0308(0x0018)(ZeroConstructor, Transient, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	TSubclassOf<class UInputComponent>            OverrideInputComponentClass;                       // 0x0320(0x0008)(Edit, ZeroConstructor, DisableEditOnInstance, NoDestructor, Protected, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierProtected)

public:
	static class AActor* GetMovementBaseActor(const class APawn* Pawn);

	void AddControllerPitchInput(float val);
	void AddControllerRollInput(float val);
	void AddControllerYawInput(float val);
	void AddMovementInput(const struct FVector& WorldDirection, float ScaleValue, bool bForce);
	struct FVector ConsumeMovementInputVector();
	void DetachFromControllerPendingDestroy();
	void OnRep_Controller();
	void OnRep_PlayerState();
	void PawnMakeNoise(float Loudness, const struct FVector& NoiseLocation, bool bUseNoiseMakerLocation, class AActor* NoiseMaker);
	void ReceiveControllerChanged(class AController* OldController, class AController* NewController);
	void ReceivePossessed(class AController* NewController);
	void ReceiveRestarted();
	void ReceiveUnpossessed(class AController* OldController);
	void SetCanAffectNavigationGeneration(bool bNewValue, bool bForceUpdate);
	void SpawnDefaultController();

	struct FRotator GetBaseAimRotation() const;
	class AController* GetController() const;
	struct FRotator GetControlRotation() const;
	struct FVector GetLastMovementInputVector() const;
	class APlayerController* GetLocalViewingPlayerController() const;
	class UPawnMovementComponent* GetMovementComponent() const;
	struct FVector GetNavAgentLocation() const;
	TSubclassOf<class UInputComponent> GetOverrideInputComponentClass() const;
	struct FVector GetPendingMovementInputVector() const;
	struct FPlatformUserId GetPlatformUserId() const;
	bool IsBotControlled() const;
	bool IsControlled() const;
	bool IsLocallyControlled() const;
	bool IsLocallyViewed() const;
	bool IsMoveInputIgnored() const;
	bool IsPawnControlled() const;
	bool IsPlayerControlled() const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"Pawn">();
	}
	static class APawn* GetDefaultObj()
	{
		return GetDefaultObjImpl<APawn>();
	}
};
static_assert(alignof(APawn) == 0x000008, "Wrong alignment on APawn");
static_assert(sizeof(APawn) == 0x000328, "Wrong size on APawn");
static_assert(offsetof(APawn, BaseEyeHeight) == 0x0002AC, "Member 'APawn::BaseEyeHeight' has a wrong offset!");
static_assert(offsetof(APawn, AutoPossessPlayer) == 0x0002B0, "Member 'APawn::AutoPossessPlayer' has a wrong offset!");
static_assert(offsetof(APawn, AutoPossessAI) == 0x0002B1, "Member 'APawn::AutoPossessAI' has a wrong offset!");
static_assert(offsetof(APawn, RemoteViewPitch) == 0x0002B2, "Member 'APawn::RemoteViewPitch' has a wrong offset!");
static_assert(offsetof(APawn, AIControllerClass) == 0x0002B8, "Member 'APawn::AIControllerClass' has a wrong offset!");
static_assert(offsetof(APawn, PlayerState) == 0x0002C0, "Member 'APawn::PlayerState' has a wrong offset!");
static_assert(offsetof(APawn, LastHitBy) == 0x0002D0, "Member 'APawn::LastHitBy' has a wrong offset!");
static_assert(offsetof(APawn, Controller) == 0x0002D8, "Member 'APawn::Controller' has a wrong offset!");
static_assert(offsetof(APawn, PreviousController) == 0x0002E0, "Member 'APawn::PreviousController' has a wrong offset!");
static_assert(offsetof(APawn, ReceiveControllerChangedDelegate) == 0x0002EC, "Member 'APawn::ReceiveControllerChangedDelegate' has a wrong offset!");
static_assert(offsetof(APawn, ReceiveRestartedDelegate) == 0x0002ED, "Member 'APawn::ReceiveRestartedDelegate' has a wrong offset!");
static_assert(offsetof(APawn, ControlInputVector) == 0x0002F0, "Member 'APawn::ControlInputVector' has a wrong offset!");
static_assert(offsetof(APawn, LastControlInputVector) == 0x000308, "Member 'APawn::LastControlInputVector' has a wrong offset!");
static_assert(offsetof(APawn, OverrideInputComponentClass) == 0x000320, "Member 'APawn::OverrideInputComponentClass' has a wrong offset!");

// Class Engine.PlatformInterfaceBase
// 0x0010 (0x0038 - 0x0028)
class UPlatformInterfaceBase : public UObject
{
public:
	TArray<struct FDelegateArray>                 AllDelegates;                                      // 0x0028(0x0010)(ZeroConstructor, ContainsInstancedReference, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"PlatformInterfaceBase">();
	}
	static class UPlatformInterfaceBase* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPlatformInterfaceBase>();
	}
};
static_assert(alignof(UPlatformInterfaceBase) == 0x000008, "Wrong alignment on UPlatformInterfaceBase");
static_assert(sizeof(UPlatformInterfaceBase) == 0x000038, "Wrong size on UPlatformInterfaceBase");
static_assert(offsetof(UPlatformInterfaceBase, AllDelegates) == 0x000028, "Member 'UPlatformInterfaceBase::AllDelegates' has a wrong offset!");

// Class Engine.MicroTransactionBase
// 0x0030 (0x0068 - 0x0038)
class UMicroTransactionBase final : public UPlatformInterfaceBase
{
public:
	TArray<struct FPurchaseInfo>                  AvailableProducts;                                 // 0x0038(0x0010)(ZeroConstructor, NativeAccessSpecifierPublic)
	class FString                                 LastError;                                         // 0x0048(0x0010)(ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FString                                 LastErrorSolution;                                 // 0x0058(0x0010)(ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MicroTransactionBase">();
	}
	static class UMicroTransactionBase* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMicroTransactionBase>();
	}
};
static_assert(alignof(UMicroTransactionBase) == 0x000008, "Wrong alignment on UMicroTransactionBase");
static_assert(sizeof(UMicroTransactionBase) == 0x000068, "Wrong size on UMicroTransactionBase");
static_assert(offsetof(UMicroTransactionBase, AvailableProducts) == 0x000038, "Member 'UMicroTransactionBase::AvailableProducts' has a wrong offset!");
static_assert(offsetof(UMicroTransactionBase, LastError) == 0x000048, "Member 'UMicroTransactionBase::LastError' has a wrong offset!");
static_assert(offsetof(UMicroTransactionBase, LastErrorSolution) == 0x000058, "Member 'UMicroTransactionBase::LastErrorSolution' has a wrong offset!");

// Class Engine.DialogueWave
// 0x0048 (0x0070 - 0x0028)
class UDialogueWave final : public UObject
{
public:
	uint8                                         bMature : 1;                                       // 0x0028(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, AssetRegistrySearchable, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bOverride_SubtitleOverride : 1;                    // 0x0028(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_29[0x7];                                       // 0x0029(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	class FString                                 SpokenText;                                        // 0x0030(0x0010)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FString                                 SubtitleOverride;                                  // 0x0040(0x0010)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TArray<struct FDialogueContextMapping>        ContextMappings;                                   // 0x0050(0x0010)(Edit, ZeroConstructor, NativeAccessSpecifierPublic)
	struct FGuid                                  LocalizationGUID;                                  // 0x0060(0x0010)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"DialogueWave">();
	}
	static class UDialogueWave* GetDefaultObj()
	{
		return GetDefaultObjImpl<UDialogueWave>();
	}
};
static_assert(alignof(UDialogueWave) == 0x000008, "Wrong alignment on UDialogueWave");
static_assert(sizeof(UDialogueWave) == 0x000070, "Wrong size on UDialogueWave");
static_assert(offsetof(UDialogueWave, SpokenText) == 0x000030, "Member 'UDialogueWave::SpokenText' has a wrong offset!");
static_assert(offsetof(UDialogueWave, SubtitleOverride) == 0x000040, "Member 'UDialogueWave::SubtitleOverride' has a wrong offset!");
static_assert(offsetof(UDialogueWave, ContextMappings) == 0x000050, "Member 'UDialogueWave::ContextMappings' has a wrong offset!");
static_assert(offsetof(UDialogueWave, LocalizationGUID) == 0x000060, "Member 'UDialogueWave::LocalizationGUID' has a wrong offset!");

// Class Engine.HLODBuilder
// 0x0000 (0x0028 - 0x0028)
class UHLODBuilder : public UObject
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"HLODBuilder">();
	}
	static class UHLODBuilder* GetDefaultObj()
	{
		return GetDefaultObjImpl<UHLODBuilder>();
	}
};
static_assert(alignof(UHLODBuilder) == 0x000008, "Wrong alignment on UHLODBuilder");
static_assert(sizeof(UHLODBuilder) == 0x000028, "Wrong size on UHLODBuilder");

// Class Engine.NavPathObserverInterface
// 0x0000 (0x0000 - 0x0000)
class INavPathObserverInterface final
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"NavPathObserverInterface">();
	}
	static class INavPathObserverInterface* GetDefaultObj()
	{
		return GetDefaultObjImpl<INavPathObserverInterface>();
	}

	class UObject* AsUObject()
	{
		return reinterpret_cast<UObject*>(this);
	}
	const class UObject* AsUObject() const
	{
		return reinterpret_cast<const UObject*>(this);
	}
};
static_assert(alignof(INavPathObserverInterface) == 0x000001, "Wrong alignment on INavPathObserverInterface");
static_assert(sizeof(INavPathObserverInterface) == 0x000001, "Wrong size on INavPathObserverInterface");

// Class Engine.MaterialExpressionRotator
// 0x0060 (0x0110 - 0x00B0)
class UMaterialExpressionRotator final : public UMaterialExpression
{
public:
	struct FExpressionInput                       Coordinate;                                        // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       Time;                                              // 0x00D8(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	float                                         CenterX;                                           // 0x0100(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         CenterY;                                           // 0x0104(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         Speed;                                             // 0x0108(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint32                                        ConstCoordinate;                                   // 0x010C(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionRotator">();
	}
	static class UMaterialExpressionRotator* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionRotator>();
	}
};
static_assert(alignof(UMaterialExpressionRotator) == 0x000008, "Wrong alignment on UMaterialExpressionRotator");
static_assert(sizeof(UMaterialExpressionRotator) == 0x000110, "Wrong size on UMaterialExpressionRotator");
static_assert(offsetof(UMaterialExpressionRotator, Coordinate) == 0x0000B0, "Member 'UMaterialExpressionRotator::Coordinate' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionRotator, Time) == 0x0000D8, "Member 'UMaterialExpressionRotator::Time' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionRotator, CenterX) == 0x000100, "Member 'UMaterialExpressionRotator::CenterX' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionRotator, CenterY) == 0x000104, "Member 'UMaterialExpressionRotator::CenterY' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionRotator, Speed) == 0x000108, "Member 'UMaterialExpressionRotator::Speed' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionRotator, ConstCoordinate) == 0x00010C, "Member 'UMaterialExpressionRotator::ConstCoordinate' has a wrong offset!");

// Class Engine.NetworkPredictionInterface
// 0x0000 (0x0000 - 0x0000)
class INetworkPredictionInterface final
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"NetworkPredictionInterface">();
	}
	static class INetworkPredictionInterface* GetDefaultObj()
	{
		return GetDefaultObjImpl<INetworkPredictionInterface>();
	}

	class UObject* AsUObject()
	{
		return reinterpret_cast<UObject*>(this);
	}
	const class UObject* AsUObject() const
	{
		return reinterpret_cast<const UObject*>(this);
	}
};
static_assert(alignof(INetworkPredictionInterface) == 0x000001, "Wrong alignment on INetworkPredictionInterface");
static_assert(sizeof(INetworkPredictionInterface) == 0x000001, "Wrong size on INetworkPredictionInterface");

// Class Engine.TickableWorldSubsystem
// 0x0010 (0x0040 - 0x0030)
class UTickableWorldSubsystem : public UWorldSubsystem
{
public:
	uint8                                         Pad_30[0x10];                                      // 0x0030(0x0010)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"TickableWorldSubsystem">();
	}
	static class UTickableWorldSubsystem* GetDefaultObj()
	{
		return GetDefaultObjImpl<UTickableWorldSubsystem>();
	}
};
static_assert(alignof(UTickableWorldSubsystem) == 0x000008, "Wrong alignment on UTickableWorldSubsystem");
static_assert(sizeof(UTickableWorldSubsystem) == 0x000040, "Wrong size on UTickableWorldSubsystem");

// Class Engine.MaterialExpressionSceneColor
// 0x0068 (0x0118 - 0x00B0)
class UMaterialExpressionSceneColor final : public UMaterialExpression
{
public:
	EMaterialSceneAttributeInputMode              InputMode;                                         // 0x00B0(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_B1[0x7];                                       // 0x00B1(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	struct FExpressionInput                       Input;                                             // 0x00B8(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       OffsetFraction;                                    // 0x00E0(0x0028)(Deprecated, NoDestructor, NativeAccessSpecifierPublic)
	struct FVector2D                              ConstInput;                                        // 0x0108(0x0010)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionSceneColor">();
	}
	static class UMaterialExpressionSceneColor* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionSceneColor>();
	}
};
static_assert(alignof(UMaterialExpressionSceneColor) == 0x000008, "Wrong alignment on UMaterialExpressionSceneColor");
static_assert(sizeof(UMaterialExpressionSceneColor) == 0x000118, "Wrong size on UMaterialExpressionSceneColor");
static_assert(offsetof(UMaterialExpressionSceneColor, InputMode) == 0x0000B0, "Member 'UMaterialExpressionSceneColor::InputMode' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionSceneColor, Input) == 0x0000B8, "Member 'UMaterialExpressionSceneColor::Input' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionSceneColor, OffsetFraction) == 0x0000E0, "Member 'UMaterialExpressionSceneColor::OffsetFraction' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionSceneColor, ConstInput) == 0x000108, "Member 'UMaterialExpressionSceneColor::ConstInput' has a wrong offset!");

// Class Engine.ParticleModuleAccelerationDragScaleOverLife
// 0x0038 (0x0070 - 0x0038)
class UParticleModuleAccelerationDragScaleOverLife final : public UParticleModuleAccelerationBase
{
public:
	class UDistributionFloat*                     DragScale;                                         // 0x0038(0x0008)(ExportObject, ZeroConstructor, InstancedReference, Deprecated, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FRawDistributionFloat                  DragScaleRaw;                                      // 0x0040(0x0030)(Edit, ContainsInstancedReference, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ParticleModuleAccelerationDragScaleOverLife">();
	}
	static class UParticleModuleAccelerationDragScaleOverLife* GetDefaultObj()
	{
		return GetDefaultObjImpl<UParticleModuleAccelerationDragScaleOverLife>();
	}
};
static_assert(alignof(UParticleModuleAccelerationDragScaleOverLife) == 0x000008, "Wrong alignment on UParticleModuleAccelerationDragScaleOverLife");
static_assert(sizeof(UParticleModuleAccelerationDragScaleOverLife) == 0x000070, "Wrong size on UParticleModuleAccelerationDragScaleOverLife");
static_assert(offsetof(UParticleModuleAccelerationDragScaleOverLife, DragScale) == 0x000038, "Member 'UParticleModuleAccelerationDragScaleOverLife::DragScale' has a wrong offset!");
static_assert(offsetof(UParticleModuleAccelerationDragScaleOverLife, DragScaleRaw) == 0x000040, "Member 'UParticleModuleAccelerationDragScaleOverLife::DragScaleRaw' has a wrong offset!");

// Class Engine.MaterialExpressionSkyAtmosphereAerialPerspective
// 0x0028 (0x00D8 - 0x00B0)
class UMaterialExpressionSkyAtmosphereAerialPerspective final : public UMaterialExpression
{
public:
	struct FExpressionInput                       WorldPosition;                                     // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionSkyAtmosphereAerialPerspective">();
	}
	static class UMaterialExpressionSkyAtmosphereAerialPerspective* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionSkyAtmosphereAerialPerspective>();
	}
};
static_assert(alignof(UMaterialExpressionSkyAtmosphereAerialPerspective) == 0x000008, "Wrong alignment on UMaterialExpressionSkyAtmosphereAerialPerspective");
static_assert(sizeof(UMaterialExpressionSkyAtmosphereAerialPerspective) == 0x0000D8, "Wrong size on UMaterialExpressionSkyAtmosphereAerialPerspective");
static_assert(offsetof(UMaterialExpressionSkyAtmosphereAerialPerspective, WorldPosition) == 0x0000B0, "Member 'UMaterialExpressionSkyAtmosphereAerialPerspective::WorldPosition' has a wrong offset!");

// Class Engine.AssetUserData
// 0x0000 (0x0028 - 0x0028)
class UAssetUserData : public UObject
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AssetUserData">();
	}
	static class UAssetUserData* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAssetUserData>();
	}
};
static_assert(alignof(UAssetUserData) == 0x000008, "Wrong alignment on UAssetUserData");
static_assert(sizeof(UAssetUserData) == 0x000028, "Wrong size on UAssetUserData");

// Class Engine.ParticleModuleAccelerationOverLifetime
// 0x0060 (0x0098 - 0x0038)
class UParticleModuleAccelerationOverLifetime final : public UParticleModuleAccelerationBase
{
public:
	struct FRawDistributionVector                 AccelOverLife;                                     // 0x0038(0x0060)(Edit, ContainsInstancedReference, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ParticleModuleAccelerationOverLifetime">();
	}
	static class UParticleModuleAccelerationOverLifetime* GetDefaultObj()
	{
		return GetDefaultObjImpl<UParticleModuleAccelerationOverLifetime>();
	}
};
static_assert(alignof(UParticleModuleAccelerationOverLifetime) == 0x000008, "Wrong alignment on UParticleModuleAccelerationOverLifetime");
static_assert(sizeof(UParticleModuleAccelerationOverLifetime) == 0x000098, "Wrong size on UParticleModuleAccelerationOverLifetime");
static_assert(offsetof(UParticleModuleAccelerationOverLifetime, AccelOverLife) == 0x000038, "Member 'UParticleModuleAccelerationOverLifetime::AccelOverLife' has a wrong offset!");

// Class Engine.CameraLensEffectInterfaceClassSupportLibrary
// 0x0000 (0x0028 - 0x0028)
class UCameraLensEffectInterfaceClassSupportLibrary final : public UBlueprintFunctionLibrary
{
public:
	static TSubclassOf<class AActor> GetInterfaceClass(const struct FCameraLensInterfaceClassSupport& CameraLens);
	static void IsInterfaceClassValid(const struct FCameraLensInterfaceClassSupport& CameraLens, EInterfaceValidResult* Result);
	static void IsInterfaceValid(const TScriptInterface<class ICameraLensEffectInterface>& CameraLens, EInterfaceValidResult* Result);
	static void SetInterfaceClass(TSubclassOf<class AActor> Class_0, struct FCameraLensInterfaceClassSupport& Var, EInterfaceValidResult* Result);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"CameraLensEffectInterfaceClassSupportLibrary">();
	}
	static class UCameraLensEffectInterfaceClassSupportLibrary* GetDefaultObj()
	{
		return GetDefaultObjImpl<UCameraLensEffectInterfaceClassSupportLibrary>();
	}
};
static_assert(alignof(UCameraLensEffectInterfaceClassSupportLibrary) == 0x000008, "Wrong alignment on UCameraLensEffectInterfaceClassSupportLibrary");
static_assert(sizeof(UCameraLensEffectInterfaceClassSupportLibrary) == 0x000028, "Wrong size on UCameraLensEffectInterfaceClassSupportLibrary");

// Class Engine.RuntimeVirtualTexture
// 0x00B8 (0x00E0 - 0x0028)
class alignas(0x10) URuntimeVirtualTexture final : public UObject
{
public:
	int32                                         TileCount;                                         // 0x0028(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	int32                                         TileSize;                                          // 0x002C(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	int32                                         TileBorderSize;                                    // 0x0030(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	ERuntimeVirtualTextureMaterialType            MaterialType;                                      // 0x0034(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, AssetRegistrySearchable, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	bool                                          bCompressTextures;                                 // 0x0035(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	bool                                          bUseLowQualityCompression;                         // 0x0036(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	bool                                          bClearTextures;                                    // 0x0037(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	bool                                          bSinglePhysicalSpace;                              // 0x0038(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	bool                                          bPrivateSpace;                                     // 0x0039(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	bool                                          bAdaptive;                                         // 0x003A(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	bool                                          bContinuousUpdate;                                 // 0x003B(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	int32                                         RemoveLowMips;                                     // 0x003C(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	ETextureGroup                                 LODGroup;                                          // 0x0040(0x0001)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, AssetRegistrySearchable, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_41[0x3];                                       // 0x0041(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	int32                                         Size;                                              // 0x0044(0x0004)(ZeroConstructor, Deprecated, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	class URuntimeVirtualTextureStreamingProxy*   StreamingTexture;                                  // 0x0048(0x0008)(ZeroConstructor, Deprecated, NoDestructor, Protected, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_50[0x90];                                      // 0x0050(0x0090)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	int32 GetPageTableSize() const;
	int32 GetSize() const;
	int32 GetTileBorderSize() const;
	int32 GetTileCount() const;
	int32 GetTileSize() const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"RuntimeVirtualTexture">();
	}
	static class URuntimeVirtualTexture* GetDefaultObj()
	{
		return GetDefaultObjImpl<URuntimeVirtualTexture>();
	}
};
static_assert(alignof(URuntimeVirtualTexture) == 0x000010, "Wrong alignment on URuntimeVirtualTexture");
static_assert(sizeof(URuntimeVirtualTexture) == 0x0000E0, "Wrong size on URuntimeVirtualTexture");
static_assert(offsetof(URuntimeVirtualTexture, TileCount) == 0x000028, "Member 'URuntimeVirtualTexture::TileCount' has a wrong offset!");
static_assert(offsetof(URuntimeVirtualTexture, TileSize) == 0x00002C, "Member 'URuntimeVirtualTexture::TileSize' has a wrong offset!");
static_assert(offsetof(URuntimeVirtualTexture, TileBorderSize) == 0x000030, "Member 'URuntimeVirtualTexture::TileBorderSize' has a wrong offset!");
static_assert(offsetof(URuntimeVirtualTexture, MaterialType) == 0x000034, "Member 'URuntimeVirtualTexture::MaterialType' has a wrong offset!");
static_assert(offsetof(URuntimeVirtualTexture, bCompressTextures) == 0x000035, "Member 'URuntimeVirtualTexture::bCompressTextures' has a wrong offset!");
static_assert(offsetof(URuntimeVirtualTexture, bUseLowQualityCompression) == 0x000036, "Member 'URuntimeVirtualTexture::bUseLowQualityCompression' has a wrong offset!");
static_assert(offsetof(URuntimeVirtualTexture, bClearTextures) == 0x000037, "Member 'URuntimeVirtualTexture::bClearTextures' has a wrong offset!");
static_assert(offsetof(URuntimeVirtualTexture, bSinglePhysicalSpace) == 0x000038, "Member 'URuntimeVirtualTexture::bSinglePhysicalSpace' has a wrong offset!");
static_assert(offsetof(URuntimeVirtualTexture, bPrivateSpace) == 0x000039, "Member 'URuntimeVirtualTexture::bPrivateSpace' has a wrong offset!");
static_assert(offsetof(URuntimeVirtualTexture, bAdaptive) == 0x00003A, "Member 'URuntimeVirtualTexture::bAdaptive' has a wrong offset!");
static_assert(offsetof(URuntimeVirtualTexture, bContinuousUpdate) == 0x00003B, "Member 'URuntimeVirtualTexture::bContinuousUpdate' has a wrong offset!");
static_assert(offsetof(URuntimeVirtualTexture, RemoveLowMips) == 0x00003C, "Member 'URuntimeVirtualTexture::RemoveLowMips' has a wrong offset!");
static_assert(offsetof(URuntimeVirtualTexture, LODGroup) == 0x000040, "Member 'URuntimeVirtualTexture::LODGroup' has a wrong offset!");
static_assert(offsetof(URuntimeVirtualTexture, Size) == 0x000044, "Member 'URuntimeVirtualTexture::Size' has a wrong offset!");
static_assert(offsetof(URuntimeVirtualTexture, StreamingTexture) == 0x000048, "Member 'URuntimeVirtualTexture::StreamingTexture' has a wrong offset!");

// Class Engine.TextureMipDataProviderFactory
// 0x0000 (0x0028 - 0x0028)
class UTextureMipDataProviderFactory : public UAssetUserData
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"TextureMipDataProviderFactory">();
	}
	static class UTextureMipDataProviderFactory* GetDefaultObj()
	{
		return GetDefaultObjImpl<UTextureMipDataProviderFactory>();
	}
};
static_assert(alignof(UTextureMipDataProviderFactory) == 0x000008, "Wrong alignment on UTextureMipDataProviderFactory");
static_assert(sizeof(UTextureMipDataProviderFactory) == 0x000028, "Wrong size on UTextureMipDataProviderFactory");

// Class Engine.ParticleModuleAttractorBase
// 0x0000 (0x0030 - 0x0030)
class UParticleModuleAttractorBase : public UParticleModule
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ParticleModuleAttractorBase">();
	}
	static class UParticleModuleAttractorBase* GetDefaultObj()
	{
		return GetDefaultObjImpl<UParticleModuleAttractorBase>();
	}
};
static_assert(alignof(UParticleModuleAttractorBase) == 0x000008, "Wrong alignment on UParticleModuleAttractorBase");
static_assert(sizeof(UParticleModuleAttractorBase) == 0x000030, "Wrong size on UParticleModuleAttractorBase");

// Class Engine.VisualLoggerKismetLibrary
// 0x0000 (0x0028 - 0x0028)
class UVisualLoggerKismetLibrary final : public UBlueprintFunctionLibrary
{
public:
	static void EnableRecording(bool bEnabled);
	static void LogBox(class UObject* WorldContextObject, const struct FBox& BoxShape, const class FString& Text, const struct FLinearColor& ObjectColor, class FName LogCategory, bool bAddToMessageLog);
	static void LogLocation(class UObject* WorldContextObject, const struct FVector& Location, const class FString& Text, const struct FLinearColor& ObjectColor, float Radius, class FName LogCategory, bool bAddToMessageLog);
	static void LogSegment(class UObject* WorldContextObject, const struct FVector& SegmentStart, const struct FVector& SegmentEnd, const class FString& Text, const struct FLinearColor& ObjectColor, const float Thickness, class FName CategoryName, bool bAddToMessageLog);
	static void LogText(class UObject* WorldContextObject, const class FString& Text, class FName LogCategory, bool bAddToMessageLog);
	static void RedirectVislog(class UObject* SourceOwner, class UObject* DestinationOwner);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"VisualLoggerKismetLibrary">();
	}
	static class UVisualLoggerKismetLibrary* GetDefaultObj()
	{
		return GetDefaultObjImpl<UVisualLoggerKismetLibrary>();
	}
};
static_assert(alignof(UVisualLoggerKismetLibrary) == 0x000008, "Wrong alignment on UVisualLoggerKismetLibrary");
static_assert(sizeof(UVisualLoggerKismetLibrary) == 0x000028, "Wrong size on UVisualLoggerKismetLibrary");

// Class Engine.MaterialExpressionSign
// 0x0028 (0x00D8 - 0x00B0)
class UMaterialExpressionSign final : public UMaterialExpression
{
public:
	struct FExpressionInput                       Input;                                             // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionSign">();
	}
	static class UMaterialExpressionSign* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionSign>();
	}
};
static_assert(alignof(UMaterialExpressionSign) == 0x000008, "Wrong alignment on UMaterialExpressionSign");
static_assert(sizeof(UMaterialExpressionSign) == 0x0000D8, "Wrong size on UMaterialExpressionSign");
static_assert(offsetof(UMaterialExpressionSign, Input) == 0x0000B0, "Member 'UMaterialExpressionSign::Input' has a wrong offset!");

// Class Engine.TextureAllMipDataProviderFactory
// 0x0000 (0x0028 - 0x0028)
class UTextureAllMipDataProviderFactory : public UTextureMipDataProviderFactory
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"TextureAllMipDataProviderFactory">();
	}
	static class UTextureAllMipDataProviderFactory* GetDefaultObj()
	{
		return GetDefaultObjImpl<UTextureAllMipDataProviderFactory>();
	}
};
static_assert(alignof(UTextureAllMipDataProviderFactory) == 0x000008, "Wrong alignment on UTextureAllMipDataProviderFactory");
static_assert(sizeof(UTextureAllMipDataProviderFactory) == 0x000028, "Wrong size on UTextureAllMipDataProviderFactory");

// Class Engine.ParticleModuleBeamNoise
// 0x0190 (0x01C0 - 0x0030)
class UParticleModuleBeamNoise final : public UParticleModuleBeamBase
{
public:
	uint8                                         bLowFreq_Enabled : 1;                              // 0x0030(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_31[0x3];                                       // 0x0031(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	int32                                         Frequency;                                         // 0x0034(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         Frequency_LowRange;                                // 0x0038(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_3C[0x4];                                       // 0x003C(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	struct FRawDistributionVector                 NoiseRange;                                        // 0x0040(0x0060)(Edit, ContainsInstancedReference, NativeAccessSpecifierPublic)
	struct FRawDistributionFloat                  NoiseRangeScale;                                   // 0x00A0(0x0030)(Edit, ContainsInstancedReference, NativeAccessSpecifierPublic)
	uint8                                         bNRScaleEmitterTime : 1;                           // 0x00D0(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_D1[0x7];                                       // 0x00D1(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	struct FRawDistributionVector                 NoiseSpeed;                                        // 0x00D8(0x0060)(Edit, ContainsInstancedReference, NativeAccessSpecifierPublic)
	uint8                                         bSmooth : 1;                                       // 0x0138(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_139[0x3];                                      // 0x0139(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         NoiseLockRadius;                                   // 0x013C(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bNoiseLock : 1;                                    // 0x0140(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bOscillate : 1;                                    // 0x0140(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_141[0x3];                                      // 0x0141(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         NoiseLockTime;                                     // 0x0144(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         NoiseTension;                                      // 0x0148(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bUseNoiseTangents : 1;                             // 0x014C(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_14D[0x3];                                      // 0x014D(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	struct FRawDistributionFloat                  NoiseTangentStrength;                              // 0x0150(0x0030)(Edit, ContainsInstancedReference, NativeAccessSpecifierPublic)
	int32                                         NoiseTessellation;                                 // 0x0180(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bTargetNoise : 1;                                  // 0x0184(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_185[0x3];                                      // 0x0185(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         FrequencyDistance;                                 // 0x0188(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bApplyNoiseScale : 1;                              // 0x018C(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_18D[0x3];                                      // 0x018D(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	struct FRawDistributionFloat                  NoiseScale;                                        // 0x0190(0x0030)(Edit, ContainsInstancedReference, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ParticleModuleBeamNoise">();
	}
	static class UParticleModuleBeamNoise* GetDefaultObj()
	{
		return GetDefaultObjImpl<UParticleModuleBeamNoise>();
	}
};
static_assert(alignof(UParticleModuleBeamNoise) == 0x000008, "Wrong alignment on UParticleModuleBeamNoise");
static_assert(sizeof(UParticleModuleBeamNoise) == 0x0001C0, "Wrong size on UParticleModuleBeamNoise");
static_assert(offsetof(UParticleModuleBeamNoise, Frequency) == 0x000034, "Member 'UParticleModuleBeamNoise::Frequency' has a wrong offset!");
static_assert(offsetof(UParticleModuleBeamNoise, Frequency_LowRange) == 0x000038, "Member 'UParticleModuleBeamNoise::Frequency_LowRange' has a wrong offset!");
static_assert(offsetof(UParticleModuleBeamNoise, NoiseRange) == 0x000040, "Member 'UParticleModuleBeamNoise::NoiseRange' has a wrong offset!");
static_assert(offsetof(UParticleModuleBeamNoise, NoiseRangeScale) == 0x0000A0, "Member 'UParticleModuleBeamNoise::NoiseRangeScale' has a wrong offset!");
static_assert(offsetof(UParticleModuleBeamNoise, NoiseSpeed) == 0x0000D8, "Member 'UParticleModuleBeamNoise::NoiseSpeed' has a wrong offset!");
static_assert(offsetof(UParticleModuleBeamNoise, NoiseLockRadius) == 0x00013C, "Member 'UParticleModuleBeamNoise::NoiseLockRadius' has a wrong offset!");
static_assert(offsetof(UParticleModuleBeamNoise, NoiseLockTime) == 0x000144, "Member 'UParticleModuleBeamNoise::NoiseLockTime' has a wrong offset!");
static_assert(offsetof(UParticleModuleBeamNoise, NoiseTension) == 0x000148, "Member 'UParticleModuleBeamNoise::NoiseTension' has a wrong offset!");
static_assert(offsetof(UParticleModuleBeamNoise, NoiseTangentStrength) == 0x000150, "Member 'UParticleModuleBeamNoise::NoiseTangentStrength' has a wrong offset!");
static_assert(offsetof(UParticleModuleBeamNoise, NoiseTessellation) == 0x000180, "Member 'UParticleModuleBeamNoise::NoiseTessellation' has a wrong offset!");
static_assert(offsetof(UParticleModuleBeamNoise, FrequencyDistance) == 0x000188, "Member 'UParticleModuleBeamNoise::FrequencyDistance' has a wrong offset!");
static_assert(offsetof(UParticleModuleBeamNoise, NoiseScale) == 0x000190, "Member 'UParticleModuleBeamNoise::NoiseScale' has a wrong offset!");

// Class Engine.Texture
// 0x0108 (0x01D0 - 0x00C8)
#pragma pack(push, 0x1)
class alignas(0x10) UTexture : public UStreamableRenderAsset
{
public:
	uint8                                         Pad_C8[0x10];                                      // 0x00C8(0x0010)(Fixing Size After Last Property [ Dumper-7 ])
	struct FGuid                                  LightingGuid;                                      // 0x00D8(0x0010)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	int32                                         LevelIndex;                                        // 0x00E8(0x0004)(ZeroConstructor, Transient, DuplicateTransient, IsPlainOldData, NonTransactional, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         LODBias;                                           // 0x00EC(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, AssetRegistrySearchable, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	ETextureCompressionSettings                   CompressionSettings;                               // 0x00F0(0x0001)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, AssetRegistrySearchable, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	ETextureFilter                                Filter;                                            // 0x00F1(0x0001)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, AssetRegistrySearchable, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	ETextureMipLoadOptions                        MipLoadOptions;                                    // 0x00F2(0x0001)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, AssetRegistrySearchable, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	ETextureCookPlatformTilingSettings            CookPlatformTilingSettings;                        // 0x00F3(0x0001)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	ETextureGroup                                 LODGroup;                                          // 0x00F4(0x0001)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, AssetRegistrySearchable, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_F5[0x3];                                       // 0x00F5(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	struct FPerPlatformFloat                      Downscale;                                         // 0x00F8(0x0004)(Edit, NoDestructor, AdvancedDisplay, NativeAccessSpecifierPublic)
	ETextureDownscaleOptions                      DownscaleOptions;                                  // 0x00FC(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         SRGB : 1;                                          // 0x00FD(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, AssetRegistrySearchable, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bNoTiling : 1;                                     // 0x00FD(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         VirtualTextureStreaming : 1;                       // 0x00FD(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, AssetRegistrySearchable, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         CompressionYCoCg : 1;                              // 0x00FD(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bNotOfflineProcessed : 1;                          // 0x00FD(0x0001)(BitIndex: 0x04, PropSize: 0x0001 (Transient, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bAsyncResourceReleaseHasBeenStarted : 1;           // 0x00FD(0x0001)(BitIndex: 0x05, PropSize: 0x0001 (Transient, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate))
	uint8                                         Pad_FE[0x2];                                       // 0x00FE(0x0002)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<class UAssetUserData*>                 AssetUserData;                                     // 0x0100(0x0010)(Edit, ExportObject, ZeroConstructor, ContainsInstancedReference, AdvancedDisplay, Protected, UObjectWrapper, NativeAccessSpecifierProtected)
	uint8                                         Pad_110[0xB8];                                     // 0x0110(0x00B8)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	int64 Blueprint_GetMemorySize() const;
	void Blueprint_GetTextureSourceDiskAndMemorySize(int64* OutDiskSize, int64* OutMemorySize) const;
	bool ComputeTextureSourceChannelMinMax(struct FLinearColor* OutColorMin, struct FLinearColor* OutColorMax) const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"Texture">();
	}
	static class UTexture* GetDefaultObj()
	{
		return GetDefaultObjImpl<UTexture>();
	}
};
#pragma pack(pop)
static_assert(alignof(UTexture) == 0x000010, "Wrong alignment on UTexture");
static_assert(sizeof(UTexture) == 0x0001D0, "Wrong size on UTexture");
static_assert(offsetof(UTexture, LightingGuid) == 0x0000D8, "Member 'UTexture::LightingGuid' has a wrong offset!");
static_assert(offsetof(UTexture, LevelIndex) == 0x0000E8, "Member 'UTexture::LevelIndex' has a wrong offset!");
static_assert(offsetof(UTexture, LODBias) == 0x0000EC, "Member 'UTexture::LODBias' has a wrong offset!");
static_assert(offsetof(UTexture, CompressionSettings) == 0x0000F0, "Member 'UTexture::CompressionSettings' has a wrong offset!");
static_assert(offsetof(UTexture, Filter) == 0x0000F1, "Member 'UTexture::Filter' has a wrong offset!");
static_assert(offsetof(UTexture, MipLoadOptions) == 0x0000F2, "Member 'UTexture::MipLoadOptions' has a wrong offset!");
static_assert(offsetof(UTexture, CookPlatformTilingSettings) == 0x0000F3, "Member 'UTexture::CookPlatformTilingSettings' has a wrong offset!");
static_assert(offsetof(UTexture, LODGroup) == 0x0000F4, "Member 'UTexture::LODGroup' has a wrong offset!");
static_assert(offsetof(UTexture, Downscale) == 0x0000F8, "Member 'UTexture::Downscale' has a wrong offset!");
static_assert(offsetof(UTexture, DownscaleOptions) == 0x0000FC, "Member 'UTexture::DownscaleOptions' has a wrong offset!");
static_assert(offsetof(UTexture, AssetUserData) == 0x000100, "Member 'UTexture::AssetUserData' has a wrong offset!");

// Class Engine.TextureRenderTarget
// 0x0000 (0x01D0 - 0x01D0)
class UTextureRenderTarget : public UTexture
{
public:
	float                                         TargetGamma;                                       // 0x01C8(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1CC[0x4];                                      // 0x01CC(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"TextureRenderTarget">();
	}
	static class UTextureRenderTarget* GetDefaultObj()
	{
		return GetDefaultObjImpl<UTextureRenderTarget>();
	}
};
static_assert(alignof(UTextureRenderTarget) == 0x000010, "Wrong alignment on UTextureRenderTarget");
static_assert(sizeof(UTextureRenderTarget) == 0x0001D0, "Wrong size on UTextureRenderTarget");
static_assert(offsetof(UTextureRenderTarget, TargetGamma) == 0x0001C8, "Member 'UTextureRenderTarget::TargetGamma' has a wrong offset!");

// Class Engine.TextureRenderTarget2D
// 0x0030 (0x0200 - 0x01D0)
#pragma pack(push, 0x1)
class alignas(0x10) UTextureRenderTarget2D : public UTextureRenderTarget
{
public:
	int32                                         SizeX;                                             // 0x01D0(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, AssetRegistrySearchable, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         SizeY;                                             // 0x01D4(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, AssetRegistrySearchable, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FLinearColor                           ClearColor;                                        // 0x01D8(0x0010)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	ETextureAddress                               AddressX;                                          // 0x01E8(0x0001)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, AssetRegistrySearchable, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	ETextureAddress                               AddressY;                                          // 0x01E9(0x0001)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, AssetRegistrySearchable, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bForceLinearGamma : 1;                             // 0x01EA(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bHDR : 1;                                          // 0x01EA(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Deprecated, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bGPUSharedFlag : 1;                                // 0x01EA(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, AssetRegistrySearchable, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	ETextureRenderTargetFormat                    RenderTargetFormat;                                // 0x01EB(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, AssetRegistrySearchable, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bAutoGenerateMips : 1;                             // 0x01EC(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, AssetRegistrySearchable, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	ETextureFilter                                MipsSamplerFilter;                                 // 0x01ED(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, AssetRegistrySearchable, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	ETextureAddress                               MipsAddressU;                                      // 0x01EE(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, AssetRegistrySearchable, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	ETextureAddress                               MipsAddressV;                                      // 0x01EF(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, AssetRegistrySearchable, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EPixelFormat                                  OverrideFormat;                                    // 0x01F0(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1F1[0x7];                                      // 0x01F1(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"TextureRenderTarget2D">();
	}
	static class UTextureRenderTarget2D* GetDefaultObj()
	{
		return GetDefaultObjImpl<UTextureRenderTarget2D>();
	}
};
#pragma pack(pop)
static_assert(alignof(UTextureRenderTarget2D) == 0x000010, "Wrong alignment on UTextureRenderTarget2D");
static_assert(sizeof(UTextureRenderTarget2D) == 0x000200, "Wrong size on UTextureRenderTarget2D");
static_assert(offsetof(UTextureRenderTarget2D, SizeX) == 0x0001D0, "Member 'UTextureRenderTarget2D::SizeX' has a wrong offset!");
static_assert(offsetof(UTextureRenderTarget2D, SizeY) == 0x0001D4, "Member 'UTextureRenderTarget2D::SizeY' has a wrong offset!");
static_assert(offsetof(UTextureRenderTarget2D, ClearColor) == 0x0001D8, "Member 'UTextureRenderTarget2D::ClearColor' has a wrong offset!");
static_assert(offsetof(UTextureRenderTarget2D, AddressX) == 0x0001E8, "Member 'UTextureRenderTarget2D::AddressX' has a wrong offset!");
static_assert(offsetof(UTextureRenderTarget2D, AddressY) == 0x0001E9, "Member 'UTextureRenderTarget2D::AddressY' has a wrong offset!");
static_assert(offsetof(UTextureRenderTarget2D, RenderTargetFormat) == 0x0001EB, "Member 'UTextureRenderTarget2D::RenderTargetFormat' has a wrong offset!");
static_assert(offsetof(UTextureRenderTarget2D, MipsSamplerFilter) == 0x0001ED, "Member 'UTextureRenderTarget2D::MipsSamplerFilter' has a wrong offset!");
static_assert(offsetof(UTextureRenderTarget2D, MipsAddressU) == 0x0001EE, "Member 'UTextureRenderTarget2D::MipsAddressU' has a wrong offset!");
static_assert(offsetof(UTextureRenderTarget2D, MipsAddressV) == 0x0001EF, "Member 'UTextureRenderTarget2D::MipsAddressV' has a wrong offset!");
static_assert(offsetof(UTextureRenderTarget2D, OverrideFormat) == 0x0001F0, "Member 'UTextureRenderTarget2D::OverrideFormat' has a wrong offset!");

// Class Engine.DynamicSubsystem
// 0x0000 (0x0030 - 0x0030)
class UDynamicSubsystem : public USubsystem
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"DynamicSubsystem">();
	}
	static class UDynamicSubsystem* GetDefaultObj()
	{
		return GetDefaultObjImpl<UDynamicSubsystem>();
	}
};
static_assert(alignof(UDynamicSubsystem) == 0x000008, "Wrong alignment on UDynamicSubsystem");
static_assert(sizeof(UDynamicSubsystem) == 0x000030, "Wrong size on UDynamicSubsystem");

// Class Engine.EngineCustomTimeStep
// 0x0000 (0x0028 - 0x0028)
class UEngineCustomTimeStep : public UObject
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"EngineCustomTimeStep">();
	}
	static class UEngineCustomTimeStep* GetDefaultObj()
	{
		return GetDefaultObjImpl<UEngineCustomTimeStep>();
	}
};
static_assert(alignof(UEngineCustomTimeStep) == 0x000008, "Wrong alignment on UEngineCustomTimeStep");
static_assert(sizeof(UEngineCustomTimeStep) == 0x000028, "Wrong size on UEngineCustomTimeStep");

// Class Engine.TimecodeProvider
// 0x0008 (0x0030 - 0x0028)
class UTimecodeProvider : public UObject
{
public:
	float                                         FrameDelay;                                        // 0x0028(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_2C[0x4];                                       // 0x002C(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void FetchAndUpdate();
	bool FetchTimecode(struct FQualifiedFrameTime* OutFrameTime);

	struct FQualifiedFrameTime GetDelayedQualifiedFrameTime() const;
	struct FTimecode GetDelayedTimecode() const;
	struct FFrameRate GetFrameRate() const;
	struct FQualifiedFrameTime GetQualifiedFrameTime() const;
	ETimecodeProviderSynchronizationState GetSynchronizationState() const;
	struct FTimecode GetTimecode() const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"TimecodeProvider">();
	}
	static class UTimecodeProvider* GetDefaultObj()
	{
		return GetDefaultObjImpl<UTimecodeProvider>();
	}
};
static_assert(alignof(UTimecodeProvider) == 0x000008, "Wrong alignment on UTimecodeProvider");
static_assert(sizeof(UTimecodeProvider) == 0x000030, "Wrong size on UTimecodeProvider");
static_assert(offsetof(UTimecodeProvider, FrameDelay) == 0x000028, "Member 'UTimecodeProvider::FrameDelay' has a wrong offset!");

// Class Engine.EdGraph
// 0x0038 (0x0060 - 0x0028)
class UEdGraph : public UObject
{
public:
	TSubclassOf<class UEdGraphSchema>             Schema;                                            // 0x0028(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TArray<class UEdGraphNode*>                   Nodes;                                             // 0x0030(0x0010)(ZeroConstructor, UObjectWrapper, NativeAccessSpecifierPublic)
	uint8                                         bEditable : 1;                                     // 0x0040(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bAllowDeletion : 1;                                // 0x0040(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bAllowRenaming : 1;                                // 0x0040(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_41[0x1F];                                      // 0x0041(0x001F)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"EdGraph">();
	}
	static class UEdGraph* GetDefaultObj()
	{
		return GetDefaultObjImpl<UEdGraph>();
	}
};
static_assert(alignof(UEdGraph) == 0x000008, "Wrong alignment on UEdGraph");
static_assert(sizeof(UEdGraph) == 0x000060, "Wrong size on UEdGraph");
static_assert(offsetof(UEdGraph, Schema) == 0x000028, "Member 'UEdGraph::Schema' has a wrong offset!");
static_assert(offsetof(UEdGraph, Nodes) == 0x000030, "Member 'UEdGraph::Nodes' has a wrong offset!");

// Class Engine.MaterialExpressionDDY
// 0x0028 (0x00D8 - 0x00B0)
class UMaterialExpressionDDY final : public UMaterialExpression
{
public:
	struct FExpressionInput                       Value;                                             // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionDDY">();
	}
	static class UMaterialExpressionDDY* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionDDY>();
	}
};
static_assert(alignof(UMaterialExpressionDDY) == 0x000008, "Wrong alignment on UMaterialExpressionDDY");
static_assert(sizeof(UMaterialExpressionDDY) == 0x0000D8, "Wrong size on UMaterialExpressionDDY");
static_assert(offsetof(UMaterialExpressionDDY, Value) == 0x0000B0, "Member 'UMaterialExpressionDDY::Value' has a wrong offset!");

// Class Engine.MaterialExpressionSkyAtmosphereDistantLightScatteredLuminance
// 0x0000 (0x00B0 - 0x00B0)
class UMaterialExpressionSkyAtmosphereDistantLightScatteredLuminance final : public UMaterialExpression
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionSkyAtmosphereDistantLightScatteredLuminance">();
	}
	static class UMaterialExpressionSkyAtmosphereDistantLightScatteredLuminance* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionSkyAtmosphereDistantLightScatteredLuminance>();
	}
};
static_assert(alignof(UMaterialExpressionSkyAtmosphereDistantLightScatteredLuminance) == 0x000008, "Wrong alignment on UMaterialExpressionSkyAtmosphereDistantLightScatteredLuminance");
static_assert(sizeof(UMaterialExpressionSkyAtmosphereDistantLightScatteredLuminance) == 0x0000B0, "Wrong size on UMaterialExpressionSkyAtmosphereDistantLightScatteredLuminance");

// Class Engine.GameUserSettings
// 0x0120 (0x0148 - 0x0028)
class UGameUserSettings : public UObject
{
public:
	bool                                          bUseVSync;                                         // 0x0028(0x0001)(ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bUseDynamicResolution;                             // 0x0029(0x0001)(ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_2A[0x5E];                                      // 0x002A(0x005E)(Fixing Size After Last Property [ Dumper-7 ])
	uint32                                        ResolutionSizeX;                                   // 0x0088(0x0004)(ZeroConstructor, Config, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint32                                        ResolutionSizeY;                                   // 0x008C(0x0004)(ZeroConstructor, Config, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint32                                        LastUserConfirmedResolutionSizeX;                  // 0x0090(0x0004)(ZeroConstructor, Config, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint32                                        LastUserConfirmedResolutionSizeY;                  // 0x0094(0x0004)(ZeroConstructor, Config, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	int32                                         WindowPosX;                                        // 0x0098(0x0004)(ZeroConstructor, Config, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	int32                                         WindowPosY;                                        // 0x009C(0x0004)(ZeroConstructor, Config, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	int32                                         FullscreenMode;                                    // 0x00A0(0x0004)(ZeroConstructor, Config, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	int32                                         LastConfirmedFullscreenMode;                       // 0x00A4(0x0004)(ZeroConstructor, Config, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	int32                                         PreferredFullscreenMode;                           // 0x00A8(0x0004)(ZeroConstructor, Config, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint32                                        Version;                                           // 0x00AC(0x0004)(ZeroConstructor, Config, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	int32                                         AudioQualityLevel;                                 // 0x00B0(0x0004)(ZeroConstructor, Config, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	int32                                         LastConfirmedAudioQualityLevel;                    // 0x00B4(0x0004)(ZeroConstructor, Config, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	float                                         FrameRateLimit;                                    // 0x00B8(0x0004)(ZeroConstructor, Config, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_BC[0x4];                                       // 0x00BC(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	int32                                         DesiredScreenWidth;                                // 0x00C0(0x0004)(ZeroConstructor, Config, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	bool                                          bUseDesiredScreenHeight;                           // 0x00C4(0x0001)(ZeroConstructor, Config, GlobalConfig, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_C5[0x3];                                       // 0x00C5(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	int32                                         DesiredScreenHeight;                               // 0x00C8(0x0004)(ZeroConstructor, Config, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	int32                                         LastUserConfirmedDesiredScreenWidth;               // 0x00CC(0x0004)(ZeroConstructor, Config, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	int32                                         LastUserConfirmedDesiredScreenHeight;              // 0x00D0(0x0004)(ZeroConstructor, Config, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	float                                         LastRecommendedScreenWidth;                        // 0x00D4(0x0004)(ZeroConstructor, Config, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	float                                         LastRecommendedScreenHeight;                       // 0x00D8(0x0004)(ZeroConstructor, Config, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	float                                         LastCPUBenchmarkResult;                            // 0x00DC(0x0004)(ZeroConstructor, Config, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	float                                         LastGPUBenchmarkResult;                            // 0x00E0(0x0004)(ZeroConstructor, Config, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_E4[0x4];                                       // 0x00E4(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<float>                                 LastCPUBenchmarkSteps;                             // 0x00E8(0x0010)(ZeroConstructor, Config, Protected, NativeAccessSpecifierProtected)
	TArray<float>                                 LastGPUBenchmarkSteps;                             // 0x00F8(0x0010)(ZeroConstructor, Config, Protected, NativeAccessSpecifierProtected)
	float                                         LastGPUBenchmarkMultiplier;                        // 0x0108(0x0004)(ZeroConstructor, Config, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	bool                                          bUseHDRDisplayOutput;                              // 0x010C(0x0001)(ZeroConstructor, Config, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_10D[0x3];                                      // 0x010D(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	int32                                         HDRDisplayOutputNits;                              // 0x0110(0x0004)(ZeroConstructor, Config, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_114[0x24];                                     // 0x0114(0x0024)(Fixing Size After Last Property [ Dumper-7 ])
	TMulticastInlineDelegate<void()>              OnGameUserSettingsUINeedsUpdate;                   // 0x0138(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPrivate)

public:
	static struct FIntPoint GetDefaultResolution();
	static EWindowMode GetDefaultWindowMode();
	static struct FIntPoint GetDefaultWindowPosition();
	static int32 GetFramePace();
	static class UGameUserSettings* GetGameUserSettings();
	static int32 GetSyncInterval();

	void ApplyHardwareBenchmarkResults();
	void ApplyNonResolutionSettings();
	void ApplyResolutionSettings(bool bCheckForCommandLineOverrides);
	void ApplySettings(bool bCheckForCommandLineOverrides);
	void ConfirmVideoMode();
	void EnableHDRDisplayOutput(bool bEnable, int32 DisplayNits);
	float GetDefaultResolutionScale();
	float GetRecommendedResolutionScale();
	void LoadSettings(bool bForceReload);
	void ResetToCurrentSettings();
	void RevertVideoMode();
	void RunHardwareBenchmark(int32 WorkScale, float CPUMultiplier, float GPUMultiplier);
	void SaveSettings();
	void SetAntiAliasingQuality(int32 Value);
	void SetAudioQualityLevel(int32 QualityLevel);
	void SetBenchmarkFallbackValues();
	void SetDynamicResolutionEnabled(bool bEnable);
	void SetFoliageQuality(int32 Value);
	void SetFrameRateLimit(float NewLimit);
	void SetFullscreenMode(EWindowMode InFullscreenMode);
	void SetGlobalIlluminationQuality(int32 Value);
	void SetOverallScalabilityLevel(int32 Value);
	void SetPostProcessingQuality(int32 Value);
	void SetReflectionQuality(int32 Value);
	void SetResolutionScaleNormalized(float NewScaleNormalized);
	void SetResolutionScaleValueEx(float NewScaleValue);
	void SetScreenResolution(const struct FIntPoint& Resolution);
	void SetShadingQuality(int32 Value);
	void SetShadowQuality(int32 Value);
	void SetTextureQuality(int32 Value);
	void SetToDefaults();
	void SetViewDistanceQuality(int32 Value);
	void SetVisualEffectQuality(int32 Value);
	void SetVSyncEnabled(bool bEnable);
	void ValidateSettings();

	int32 GetAntiAliasingQuality() const;
	int32 GetAudioQualityLevel() const;
	int32 GetCurrentHDRDisplayNits() const;
	struct FIntPoint GetDesktopResolution() const;
	int32 GetFoliageQuality() const;
	float GetFrameRateLimit() const;
	EWindowMode GetFullscreenMode() const;
	int32 GetGlobalIlluminationQuality() const;
	EWindowMode GetLastConfirmedFullscreenMode() const;
	struct FIntPoint GetLastConfirmedScreenResolution() const;
	int32 GetOverallScalabilityLevel() const;
	int32 GetPostProcessingQuality() const;
	EWindowMode GetPreferredFullscreenMode() const;
	int32 GetReflectionQuality() const;
	void GetResolutionScaleInformationEx(float* CurrentScaleNormalized, float* CurrentScaleValue, float* MinScaleValue, float* MaxScaleValue) const;
	float GetResolutionScaleNormalized() const;
	struct FIntPoint GetScreenResolution() const;
	int32 GetShadingQuality() const;
	int32 GetShadowQuality() const;
	int32 GetTextureQuality() const;
	int32 GetViewDistanceQuality() const;
	int32 GetVisualEffectQuality() const;
	bool IsDirty() const;
	bool IsDynamicResolutionDirty() const;
	bool IsDynamicResolutionEnabled() const;
	bool IsFullscreenModeDirty() const;
	bool IsHDREnabled() const;
	bool IsScreenResolutionDirty() const;
	bool IsVSyncDirty() const;
	bool IsVSyncEnabled() const;
	bool SupportsHDRDisplayOutput() const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"GameUserSettings">();
	}
	static class UGameUserSettings* GetDefaultObj()
	{
		return GetDefaultObjImpl<UGameUserSettings>();
	}
};
static_assert(alignof(UGameUserSettings) == 0x000008, "Wrong alignment on UGameUserSettings");
static_assert(sizeof(UGameUserSettings) == 0x000148, "Wrong size on UGameUserSettings");
static_assert(offsetof(UGameUserSettings, bUseVSync) == 0x000028, "Member 'UGameUserSettings::bUseVSync' has a wrong offset!");
static_assert(offsetof(UGameUserSettings, bUseDynamicResolution) == 0x000029, "Member 'UGameUserSettings::bUseDynamicResolution' has a wrong offset!");
static_assert(offsetof(UGameUserSettings, ResolutionSizeX) == 0x000088, "Member 'UGameUserSettings::ResolutionSizeX' has a wrong offset!");
static_assert(offsetof(UGameUserSettings, ResolutionSizeY) == 0x00008C, "Member 'UGameUserSettings::ResolutionSizeY' has a wrong offset!");
static_assert(offsetof(UGameUserSettings, LastUserConfirmedResolutionSizeX) == 0x000090, "Member 'UGameUserSettings::LastUserConfirmedResolutionSizeX' has a wrong offset!");
static_assert(offsetof(UGameUserSettings, LastUserConfirmedResolutionSizeY) == 0x000094, "Member 'UGameUserSettings::LastUserConfirmedResolutionSizeY' has a wrong offset!");
static_assert(offsetof(UGameUserSettings, WindowPosX) == 0x000098, "Member 'UGameUserSettings::WindowPosX' has a wrong offset!");
static_assert(offsetof(UGameUserSettings, WindowPosY) == 0x00009C, "Member 'UGameUserSettings::WindowPosY' has a wrong offset!");
static_assert(offsetof(UGameUserSettings, FullscreenMode) == 0x0000A0, "Member 'UGameUserSettings::FullscreenMode' has a wrong offset!");
static_assert(offsetof(UGameUserSettings, LastConfirmedFullscreenMode) == 0x0000A4, "Member 'UGameUserSettings::LastConfirmedFullscreenMode' has a wrong offset!");
static_assert(offsetof(UGameUserSettings, PreferredFullscreenMode) == 0x0000A8, "Member 'UGameUserSettings::PreferredFullscreenMode' has a wrong offset!");
static_assert(offsetof(UGameUserSettings, Version) == 0x0000AC, "Member 'UGameUserSettings::Version' has a wrong offset!");
static_assert(offsetof(UGameUserSettings, AudioQualityLevel) == 0x0000B0, "Member 'UGameUserSettings::AudioQualityLevel' has a wrong offset!");
static_assert(offsetof(UGameUserSettings, LastConfirmedAudioQualityLevel) == 0x0000B4, "Member 'UGameUserSettings::LastConfirmedAudioQualityLevel' has a wrong offset!");
static_assert(offsetof(UGameUserSettings, FrameRateLimit) == 0x0000B8, "Member 'UGameUserSettings::FrameRateLimit' has a wrong offset!");
static_assert(offsetof(UGameUserSettings, DesiredScreenWidth) == 0x0000C0, "Member 'UGameUserSettings::DesiredScreenWidth' has a wrong offset!");
static_assert(offsetof(UGameUserSettings, bUseDesiredScreenHeight) == 0x0000C4, "Member 'UGameUserSettings::bUseDesiredScreenHeight' has a wrong offset!");
static_assert(offsetof(UGameUserSettings, DesiredScreenHeight) == 0x0000C8, "Member 'UGameUserSettings::DesiredScreenHeight' has a wrong offset!");
static_assert(offsetof(UGameUserSettings, LastUserConfirmedDesiredScreenWidth) == 0x0000CC, "Member 'UGameUserSettings::LastUserConfirmedDesiredScreenWidth' has a wrong offset!");
static_assert(offsetof(UGameUserSettings, LastUserConfirmedDesiredScreenHeight) == 0x0000D0, "Member 'UGameUserSettings::LastUserConfirmedDesiredScreenHeight' has a wrong offset!");
static_assert(offsetof(UGameUserSettings, LastRecommendedScreenWidth) == 0x0000D4, "Member 'UGameUserSettings::LastRecommendedScreenWidth' has a wrong offset!");
static_assert(offsetof(UGameUserSettings, LastRecommendedScreenHeight) == 0x0000D8, "Member 'UGameUserSettings::LastRecommendedScreenHeight' has a wrong offset!");
static_assert(offsetof(UGameUserSettings, LastCPUBenchmarkResult) == 0x0000DC, "Member 'UGameUserSettings::LastCPUBenchmarkResult' has a wrong offset!");
static_assert(offsetof(UGameUserSettings, LastGPUBenchmarkResult) == 0x0000E0, "Member 'UGameUserSettings::LastGPUBenchmarkResult' has a wrong offset!");
static_assert(offsetof(UGameUserSettings, LastCPUBenchmarkSteps) == 0x0000E8, "Member 'UGameUserSettings::LastCPUBenchmarkSteps' has a wrong offset!");
static_assert(offsetof(UGameUserSettings, LastGPUBenchmarkSteps) == 0x0000F8, "Member 'UGameUserSettings::LastGPUBenchmarkSteps' has a wrong offset!");
static_assert(offsetof(UGameUserSettings, LastGPUBenchmarkMultiplier) == 0x000108, "Member 'UGameUserSettings::LastGPUBenchmarkMultiplier' has a wrong offset!");
static_assert(offsetof(UGameUserSettings, bUseHDRDisplayOutput) == 0x00010C, "Member 'UGameUserSettings::bUseHDRDisplayOutput' has a wrong offset!");
static_assert(offsetof(UGameUserSettings, HDRDisplayOutputNits) == 0x000110, "Member 'UGameUserSettings::HDRDisplayOutputNits' has a wrong offset!");
static_assert(offsetof(UGameUserSettings, OnGameUserSettingsUINeedsUpdate) == 0x000138, "Member 'UGameUserSettings::OnGameUserSettingsUINeedsUpdate' has a wrong offset!");

// Class Engine.DebugDrawComponent
// 0x0050 (0x05C0 - 0x0570)
class UDebugDrawComponent : public UPrimitiveComponent
{
public:
	uint8                                         Pad_570[0x50];                                     // 0x0570(0x0050)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"DebugDrawComponent">();
	}
	static class UDebugDrawComponent* GetDefaultObj()
	{
		return GetDefaultObjImpl<UDebugDrawComponent>();
	}
};
static_assert(alignof(UDebugDrawComponent) == 0x000010, "Wrong alignment on UDebugDrawComponent");
static_assert(sizeof(UDebugDrawComponent) == 0x0005C0, "Wrong size on UDebugDrawComponent");

// Class Engine.MaterialExpressionParticleDirection
// 0x0000 (0x00B0 - 0x00B0)
class UMaterialExpressionParticleDirection final : public UMaterialExpression
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionParticleDirection">();
	}
	static class UMaterialExpressionParticleDirection* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionParticleDirection>();
	}
};
static_assert(alignof(UMaterialExpressionParticleDirection) == 0x000008, "Wrong alignment on UMaterialExpressionParticleDirection");
static_assert(sizeof(UMaterialExpressionParticleDirection) == 0x0000B0, "Wrong size on UMaterialExpressionParticleDirection");

// Class Engine.MaterialExpressionShadingModel
// 0x0008 (0x00B8 - 0x00B0)
class UMaterialExpressionShadingModel final : public UMaterialExpression
{
public:
	EMaterialShadingModel                         ShadingModel;                                      // 0x00B0(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_B1[0x7];                                       // 0x00B1(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionShadingModel">();
	}
	static class UMaterialExpressionShadingModel* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionShadingModel>();
	}
};
static_assert(alignof(UMaterialExpressionShadingModel) == 0x000008, "Wrong alignment on UMaterialExpressionShadingModel");
static_assert(sizeof(UMaterialExpressionShadingModel) == 0x0000B8, "Wrong size on UMaterialExpressionShadingModel");
static_assert(offsetof(UMaterialExpressionShadingModel, ShadingModel) == 0x0000B0, "Member 'UMaterialExpressionShadingModel::ShadingModel' has a wrong offset!");

// Class Engine.AnimNotify
// 0x0010 (0x0038 - 0x0028)
class UAnimNotify : public UObject
{
public:
	uint8                                         Pad_28[0x10];                                      // 0x0028(0x0010)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	float GetDefaultTriggerWeightThreshold() const;
	class FString GetNotifyName() const;
	bool Received_Notify(class USkeletalMeshComponent* meshComp, class UAnimSequenceBase* Animation, const struct FAnimNotifyEventReference& EventReference) const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AnimNotify">();
	}
	static class UAnimNotify* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAnimNotify>();
	}
};
static_assert(alignof(UAnimNotify) == 0x000008, "Wrong alignment on UAnimNotify");
static_assert(sizeof(UAnimNotify) == 0x000038, "Wrong size on UAnimNotify");

// Class Engine.DynamicBlueprintBinding
// 0x0000 (0x0028 - 0x0028)
class UDynamicBlueprintBinding : public UObject
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"DynamicBlueprintBinding">();
	}
	static class UDynamicBlueprintBinding* GetDefaultObj()
	{
		return GetDefaultObjImpl<UDynamicBlueprintBinding>();
	}
};
static_assert(alignof(UDynamicBlueprintBinding) == 0x000008, "Wrong alignment on UDynamicBlueprintBinding");
static_assert(sizeof(UDynamicBlueprintBinding) == 0x000028, "Wrong size on UDynamicBlueprintBinding");

// Class Engine.MaterialInterfaceEditorOnlyData
// 0x0018 (0x0040 - 0x0028)
class UMaterialInterfaceEditorOnlyData : public UObject
{
public:
	uint8                                         Pad_28[0x18];                                      // 0x0028(0x0018)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialInterfaceEditorOnlyData">();
	}
	static class UMaterialInterfaceEditorOnlyData* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialInterfaceEditorOnlyData>();
	}
};
static_assert(alignof(UMaterialInterfaceEditorOnlyData) == 0x000008, "Wrong alignment on UMaterialInterfaceEditorOnlyData");
static_assert(sizeof(UMaterialInterfaceEditorOnlyData) == 0x000040, "Wrong size on UMaterialInterfaceEditorOnlyData");

// Class Engine.AnimNotifyState
// 0x0008 (0x0030 - 0x0028)
class UAnimNotifyState : public UObject
{
public:
	uint8                                         Pad_28[0x8];                                       // 0x0028(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	float GetDefaultTriggerWeightThreshold() const;
	class FString GetNotifyName() const;
	bool Received_NotifyBegin(class USkeletalMeshComponent* meshComp, class UAnimSequenceBase* Animation, float TotalDuration, const struct FAnimNotifyEventReference& EventReference) const;
	bool Received_NotifyEnd(class USkeletalMeshComponent* meshComp, class UAnimSequenceBase* Animation, const struct FAnimNotifyEventReference& EventReference) const;
	bool Received_NotifyTick(class USkeletalMeshComponent* meshComp, class UAnimSequenceBase* Animation, float FrameDeltaTime, const struct FAnimNotifyEventReference& EventReference) const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AnimNotifyState">();
	}
	static class UAnimNotifyState* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAnimNotifyState>();
	}
};
static_assert(alignof(UAnimNotifyState) == 0x000008, "Wrong alignment on UAnimNotifyState");
static_assert(sizeof(UAnimNotifyState) == 0x000030, "Wrong size on UAnimNotifyState");

// Class Engine.MaterialExpressionParticleSpeed
// 0x0000 (0x00B0 - 0x00B0)
class UMaterialExpressionParticleSpeed final : public UMaterialExpression
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionParticleSpeed">();
	}
	static class UMaterialExpressionParticleSpeed* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionParticleSpeed>();
	}
};
static_assert(alignof(UMaterialExpressionParticleSpeed) == 0x000008, "Wrong alignment on UMaterialExpressionParticleSpeed");
static_assert(sizeof(UMaterialExpressionParticleSpeed) == 0x0000B0, "Wrong size on UMaterialExpressionParticleSpeed");

// Class Engine.SkinnedMeshComponent
// 0x0340 (0x08F0 - 0x05B0)
class USkinnedMeshComponent : public UMeshComponent
{
public:
	uint8                                         Pad_5A8[0x8];                                      // 0x05A8(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	class USkeletalMesh*                          SkeletalMesh;                                      // 0x05B0(0x0008)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class USkinnedAsset*                          SkinnedAsset;                                      // 0x05B8(0x0008)(BlueprintVisible, BlueprintReadOnly, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	TWeakObjectPtr<class USkinnedMeshComponent>   LeaderPoseComponent;                               // 0x05C0(0x0008)(BlueprintVisible, ExportObject, BlueprintReadOnly, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TArray<ESkinCacheUsage>                       SkinCacheUsage;                                    // 0x05C8(0x0010)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, NativeAccessSpecifierPublic)
	bool                                          bSetMeshDeformer;                                  // 0x05D8(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_5D9[0x7];                                      // 0x05D9(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	class UMeshDeformer*                          MeshDeformer;                                      // 0x05E0(0x0008)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, NoDestructor, Protected, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	class UMeshDeformerInstanceSettings*          MeshDeformerInstanceSettings;                      // 0x05E8(0x0008)(Edit, BlueprintVisible, ExportObject, BlueprintReadOnly, ZeroConstructor, EditConst, InstancedReference, NoDestructor, Protected, PersistentInstance, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	class UMeshDeformerInstance*                  MeshDeformerInstance;                              // 0x05F0(0x0008)(BlueprintVisible, BlueprintReadOnly, ZeroConstructor, Transient, NoDestructor, Protected, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_5F8[0x178];                                    // 0x05F8(0x0178)(Fixing Size After Last Property [ Dumper-7 ])
	class UPhysicsAsset*                          PhysicsAssetOverride;                              // 0x0770(0x0008)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, NoDestructor, AdvancedDisplay, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         ForcedLodModel;                                    // 0x0778(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         MinLodModel;                                       // 0x077C(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_780[0x8];                                      // 0x0780(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         StreamingDistanceMultiplier;                       // 0x0788(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_78C[0xC];                                      // 0x078C(0x000C)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<struct FSkelMeshComponentLODInfo>      LODInfo;                                           // 0x0798(0x0010)(ZeroConstructor, Transient, NativeAccessSpecifierPublic)
	uint8                                         Pad_7A8[0x24];                                     // 0x07A8(0x0024)(Fixing Size After Last Property [ Dumper-7 ])
	EVisibilityBasedAnimTickOption                VisibilityBasedAnimTickOption;                     // 0x07CC(0x0001)(Edit, BlueprintVisible, ZeroConstructor, Config, IsPlainOldData, Interp, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_7CD[0x1];                                      // 0x07CD(0x0001)(Fixing Size After Last Property [ Dumper-7 ])
	uint8                                         BitPad_7CE_0 : 3;                                  // 0x07CE(0x0001)(Fixing Bit-Field Size Between Bits [ Dumper-7 ])
	uint8                                         bOverrideMinLOD : 1;                               // 0x07CE(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bUseBoundsFromLeaderPoseComponent : 1;             // 0x07CE(0x0001)(BitIndex: 0x04, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bForceWireframe : 1;                               // 0x07CE(0x0001)(BitIndex: 0x05, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bDisableMorphTarget : 1;                           // 0x07CE(0x0001)(BitIndex: 0x06, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bHideSkin : 1;                                     // 0x07CE(0x0001)(BitIndex: 0x07, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bPerBoneMotionBlur : 1;                            // 0x07CF(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bComponentUseFixedSkelBounds : 1;                  // 0x07CF(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bConsiderAllBodiesForBounds : 1;                   // 0x07CF(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bSyncAttachParentLOD : 1;                          // 0x07CF(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bCanHighlightSelectedSections : 1;                 // 0x07CF(0x0001)(BitIndex: 0x04, PropSize: 0x0001 (Transient, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bRecentlyRendered : 1;                             // 0x07CF(0x0001)(BitIndex: 0x05, PropSize: 0x0001 (Transient, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bCastCapsuleDirectShadow : 1;                      // 0x07CF(0x0001)(BitIndex: 0x06, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bCastCapsuleIndirectShadow : 1;                    // 0x07CF(0x0001)(BitIndex: 0x07, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bCPUSkinning : 1;                                  // 0x07D0(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Transient, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bEnableUpdateRateOptimizations : 1;                // 0x07D0(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bDisplayDebugUpdateRateOptimizations : 1;          // 0x07D0(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bRenderStatic : 1;                                 // 0x07D0(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bIgnoreLeaderPoseComponentLOD : 1;                 // 0x07D0(0x0001)(BitIndex: 0x04, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         BitPad_7D0_5 : 2;                                  // 0x07D0(0x0001)(Fixing Bit-Field Size Between Bits [ Dumper-7 ])
	uint8                                         bCachedLocalBoundsUpToDate : 1;                    // 0x07D0(0x0001)(BitIndex: 0x07, PropSize: 0x0001 (Transient, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
	uint8                                         bCachedWorldSpaceBoundsUpToDate : 1;               // 0x07D1(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Transient, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
	uint8                                         BitPad_7D1_1 : 1;                                  // 0x07D1(0x0001)(Fixing Bit-Field Size Between Bits [ Dumper-7 ])
	uint8                                         bForceMeshObjectUpdate : 1;                        // 0x07D1(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Transient, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate))
	uint8                                         bForceUpdateDynamicDataImmediately : 1;            // 0x07D1(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (Transient, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate))
	uint8                                         BitPad_7D1_4 : 4;                                  // 0x07D1(0x0001)(Fixing Bit-Field Size For New Byte [ Dumper-7 ])
	uint8                                         BitPad_7D2_0 : 1;                                  // 0x07D2(0x0001)(Fixing Bit-Field Size Between Bits [ Dumper-7 ])
	uint8                                         bFollowerShouldTickPose : 1;                       // 0x07D2(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Transient, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
	uint8                                         Pad_7D3[0x1];                                      // 0x07D3(0x0001)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         CapsuleIndirectShadowMinVisibility;                // 0x07D4(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_7D8[0x38];                                     // 0x07D8(0x0038)(Fixing Size After Last Property [ Dumper-7 ])
	struct FBoxSphereBounds                       CachedWorldOrLocalSpaceBounds;                     // 0x0810(0x0038)(ZeroConstructor, Transient, IsPlainOldData, NoDestructor, Protected, NativeAccessSpecifierProtected)
	uint8                                         Pad_848[0x8];                                      // 0x0848(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	struct FMatrix                                CachedWorldToLocalTransform;                       // 0x0850(0x0080)(ZeroConstructor, Transient, IsPlainOldData, NoDestructor, Protected, NativeAccessSpecifierProtected)
	uint8                                         Pad_8D0[0x20];                                     // 0x08D0(0x0020)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void ClearSkinWeightOverride(int32 LODIndex);
	void ClearSkinWeightProfile();
	void ClearVertexColorOverride(int32 LODIndex);
	void HideBoneByName(class FName BoneName, EPhysBodyOp PhysBodyOption);
	bool IsBoneHiddenByName(class FName BoneName);
	bool IsMaterialSectionShown(int32 MaterialID, int32 LODIndex);
	void SetCapsuleIndirectShadowMinVisibility(float NewValue);
	void SetCastCapsuleDirectShadow(bool bNewValue);
	void SetCastCapsuleIndirectShadow(bool bNewValue);
	void SetForcedLOD(int32 InNewForcedLOD);
	void SetLeaderPoseComponent(class USkinnedMeshComponent* NewLeaderBoneComponent, bool bForceUpdate, bool bInFollowerShouldTickPose);
	void SetMeshDeformer(class UMeshDeformer* InMeshDeformer);
	void SetMinLOD(int32 InNewMinLOD);
	void SetPhysicsAsset(class UPhysicsAsset* NewPhysicsAsset, bool bForceReInit);
	void SetPostSkinningOffsets(int32 LODIndex, const TArray<struct FVector>& Offsets);
	void SetPreSkinningOffsets(int32 LODIndex, const TArray<struct FVector>& Offsets);
	void SetRenderStatic(bool bNewValue);
	void SetSkinnedAssetAndUpdate(class USkinnedAsset* NewMesh, bool bReinitPose);
	void SetSkinWeightOverride(int32 LODIndex, const TArray<struct FSkelMeshSkinWeightInfo>& SkinWeights);
	bool SetSkinWeightProfile(class FName InProfileName);
	void SetVertexColorOverride_LinearColor(int32 LODIndex, const TArray<struct FLinearColor>& VertexColors);
	void SetVertexOffsetUsage(int32 LODIndex, int32 Usage);
	void ShowAllMaterialSections(int32 LODIndex);
	void ShowMaterialSection(int32 MaterialID, int32 SectionIndex, bool bShow, int32 LODIndex);
	void TransformFromBoneSpace(class FName BoneName, const struct FVector& InPosition, const struct FRotator& InRotation, struct FVector* OutPosition, struct FRotator* OutRotation);
	void UnHideBoneByName(class FName BoneName);
	void UnloadSkinWeightProfile(class FName InProfileName);
	void UnsetMeshDeformer();

	bool BoneIsChildOf(class FName BoneName, class FName ParentBoneName) const;
	class FName FindClosestBone_K2(const struct FVector& TestLocation, struct FVector* BoneLocation, float IgnoreScale, bool bRequirePhysicsAsset) const;
	int32 GetBoneIndex(class FName BoneName) const;
	class FName GetBoneName(int32 BoneIndex) const;
	struct FTransform GetBoneTransform(class FName InBoneName, ERelativeTransformSpace TransformSpace) const;
	class FName GetCurrentSkinWeightProfileName() const;
	struct FTransform GetDeltaTransformFromRefPose(class FName BoneName, class FName BaseName) const;
	int32 GetForcedLOD() const;
	class UMeshDeformerInstance* GetMeshDeformerInstance() const;
	int32 GetNumBones() const;
	int32 GetNumLODs() const;
	class FName GetParentBone(class FName BoneName) const;
	int32 GetPredictedLODLevel() const;
	struct FVector GetRefPosePosition(int32 BoneIndex) const;
	struct FTransform GetRefPoseTransform(int32 BoneIndex) const;
	class USkeletalMesh* GetSkeletalMesh_DEPRECATED() const;
	class USkinnedAsset* GetSkinnedAsset() const;
	class FName GetSocketBoneName(class FName InSocketName) const;
	bool GetTwistAndSwingAngleOfDeltaRotationFromRefPose(class FName BoneName, float* OutTwistAngle, float* OutSwingAngle) const;
	int32 GetVertexOffsetUsage(int32 LODIndex) const;
	bool IsUsingSkinWeightProfile() const;
	void TransformToBoneSpace(class FName BoneName, const struct FVector& InPosition, const struct FRotator& InRotation, struct FVector* OutPosition, struct FRotator* OutRotation) const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"SkinnedMeshComponent">();
	}
	static class USkinnedMeshComponent* GetDefaultObj()
	{
		return GetDefaultObjImpl<USkinnedMeshComponent>();
	}
};
static_assert(alignof(USkinnedMeshComponent) == 0x000010, "Wrong alignment on USkinnedMeshComponent");
static_assert(sizeof(USkinnedMeshComponent) == 0x0008F0, "Wrong size on USkinnedMeshComponent");
static_assert(offsetof(USkinnedMeshComponent, SkeletalMesh) == 0x0005B0, "Member 'USkinnedMeshComponent::SkeletalMesh' has a wrong offset!");
static_assert(offsetof(USkinnedMeshComponent, SkinnedAsset) == 0x0005B8, "Member 'USkinnedMeshComponent::SkinnedAsset' has a wrong offset!");
static_assert(offsetof(USkinnedMeshComponent, LeaderPoseComponent) == 0x0005C0, "Member 'USkinnedMeshComponent::LeaderPoseComponent' has a wrong offset!");
static_assert(offsetof(USkinnedMeshComponent, SkinCacheUsage) == 0x0005C8, "Member 'USkinnedMeshComponent::SkinCacheUsage' has a wrong offset!");
static_assert(offsetof(USkinnedMeshComponent, bSetMeshDeformer) == 0x0005D8, "Member 'USkinnedMeshComponent::bSetMeshDeformer' has a wrong offset!");
static_assert(offsetof(USkinnedMeshComponent, MeshDeformer) == 0x0005E0, "Member 'USkinnedMeshComponent::MeshDeformer' has a wrong offset!");
static_assert(offsetof(USkinnedMeshComponent, MeshDeformerInstanceSettings) == 0x0005E8, "Member 'USkinnedMeshComponent::MeshDeformerInstanceSettings' has a wrong offset!");
static_assert(offsetof(USkinnedMeshComponent, MeshDeformerInstance) == 0x0005F0, "Member 'USkinnedMeshComponent::MeshDeformerInstance' has a wrong offset!");
static_assert(offsetof(USkinnedMeshComponent, PhysicsAssetOverride) == 0x000770, "Member 'USkinnedMeshComponent::PhysicsAssetOverride' has a wrong offset!");
static_assert(offsetof(USkinnedMeshComponent, ForcedLodModel) == 0x000778, "Member 'USkinnedMeshComponent::ForcedLodModel' has a wrong offset!");
static_assert(offsetof(USkinnedMeshComponent, MinLodModel) == 0x00077C, "Member 'USkinnedMeshComponent::MinLodModel' has a wrong offset!");
static_assert(offsetof(USkinnedMeshComponent, StreamingDistanceMultiplier) == 0x000788, "Member 'USkinnedMeshComponent::StreamingDistanceMultiplier' has a wrong offset!");
static_assert(offsetof(USkinnedMeshComponent, LODInfo) == 0x000798, "Member 'USkinnedMeshComponent::LODInfo' has a wrong offset!");
static_assert(offsetof(USkinnedMeshComponent, VisibilityBasedAnimTickOption) == 0x0007CC, "Member 'USkinnedMeshComponent::VisibilityBasedAnimTickOption' has a wrong offset!");
static_assert(offsetof(USkinnedMeshComponent, CapsuleIndirectShadowMinVisibility) == 0x0007D4, "Member 'USkinnedMeshComponent::CapsuleIndirectShadowMinVisibility' has a wrong offset!");
static_assert(offsetof(USkinnedMeshComponent, CachedWorldOrLocalSpaceBounds) == 0x000810, "Member 'USkinnedMeshComponent::CachedWorldOrLocalSpaceBounds' has a wrong offset!");
static_assert(offsetof(USkinnedMeshComponent, CachedWorldToLocalTransform) == 0x000850, "Member 'USkinnedMeshComponent::CachedWorldToLocalTransform' has a wrong offset!");

// Class Engine.MaterialExpressionParticleMotionBlurFade
// 0x0000 (0x00B0 - 0x00B0)
class UMaterialExpressionParticleMotionBlurFade final : public UMaterialExpression
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionParticleMotionBlurFade">();
	}
	static class UMaterialExpressionParticleMotionBlurFade* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionParticleMotionBlurFade>();
	}
};
static_assert(alignof(UMaterialExpressionParticleMotionBlurFade) == 0x000008, "Wrong alignment on UMaterialExpressionParticleMotionBlurFade");
static_assert(sizeof(UMaterialExpressionParticleMotionBlurFade) == 0x0000B0, "Wrong size on UMaterialExpressionParticleMotionBlurFade");

// Class Engine.LevelInstancePivot
// 0x0008 (0x02A8 - 0x02A0)
class ALevelInstancePivot final : public AActor
{
public:
	uint8                                         Pad_2A0[0x8];                                      // 0x02A0(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"LevelInstancePivot">();
	}
	static class ALevelInstancePivot* GetDefaultObj()
	{
		return GetDefaultObjImpl<ALevelInstancePivot>();
	}
};
static_assert(alignof(ALevelInstancePivot) == 0x000008, "Wrong alignment on ALevelInstancePivot");
static_assert(sizeof(ALevelInstancePivot) == 0x0002A8, "Wrong size on ALevelInstancePivot");

// Class Engine.LineBatchComponent
// 0x0040 (0x05B0 - 0x0570)
class ULineBatchComponent final : public UPrimitiveComponent
{
public:
	uint8                                         Pad_570[0x40];                                     // 0x0570(0x0040)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"LineBatchComponent">();
	}
	static class ULineBatchComponent* GetDefaultObj()
	{
		return GetDefaultObjImpl<ULineBatchComponent>();
	}
};
static_assert(alignof(ULineBatchComponent) == 0x000010, "Wrong alignment on ULineBatchComponent");
static_assert(sizeof(ULineBatchComponent) == 0x0005B0, "Wrong size on ULineBatchComponent");

// Class Engine.SkeletalMeshComponent
// 0x06D0 (0x0FC0 - 0x08F0)
#pragma pack(push, 0x1)
class alignas(0x10) USkeletalMeshComponent : public USkinnedMeshComponent
{
public:
	class USkeletalMesh*                          SkeletalMeshAsset;                                 // 0x08F0(0x0008)(Edit, BlueprintVisible, ZeroConstructor, Transient, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	TSubclassOf<class UObject>                    AnimBlueprintGeneratedClass;                       // 0x08F8(0x0008)(BlueprintVisible, BlueprintReadOnly, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TSubclassOf<class UAnimInstance>              AnimClass;                                         // 0x0900(0x0008)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UAnimInstance*                          AnimScriptInstance;                                // 0x0908(0x0008)(ZeroConstructor, Transient, NonTransactional, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UAnimInstance*                          PostProcessAnimInstance;                           // 0x0910(0x0008)(ZeroConstructor, Transient, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FSingleAnimationPlayData               AnimationData;                                     // 0x0918(0x0018)(Edit, BlueprintVisible, NoDestructor, NativeAccessSpecifierPublic)
	uint8                                         Pad_930[0x10];                                     // 0x0930(0x0010)(Fixing Size After Last Property [ Dumper-7 ])
	struct FVector                                RootBoneTranslation;                               // 0x0940(0x0018)(ZeroConstructor, Transient, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector                                LineCheckBoundsScale;                              // 0x0958(0x0018)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_970[0x20];                                     // 0x0970(0x0020)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<class UAnimInstance*>                  LinkedInstances;                                   // 0x0990(0x0010)(ZeroConstructor, Transient, UObjectWrapper, NativeAccessSpecifierPrivate)
	uint8                                         Pad_9A0[0x10];                                     // 0x09A0(0x0010)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<struct FTransform>                     CachedBoneSpaceTransforms;                         // 0x09B0(0x0010)(ZeroConstructor, Transient, NativeAccessSpecifierPrivate)
	TArray<struct FTransform>                     CachedComponentSpaceTransforms;                    // 0x09C0(0x0010)(ZeroConstructor, Transient, NativeAccessSpecifierPrivate)
	uint8                                         Pad_9D0[0xA0];                                     // 0x09D0(0x00A0)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         GlobalAnimRateScale;                               // 0x0A70(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EKinematicBonesUpdateToPhysics                KinematicBonesUpdateType;                          // 0x0A74(0x0001)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EPhysicsTransformUpdateMode                   PhysicsTransformUpdateMode;                        // 0x0A75(0x0001)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_A76[0x1];                                      // 0x0A76(0x0001)(Fixing Size After Last Property [ Dumper-7 ])
	EAnimationMode                                AnimationMode;                                     // 0x0A77(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_A78[0x1];                                      // 0x0A78(0x0001)(Fixing Size After Last Property [ Dumper-7 ])
	uint8                                         bDisablePostProcessBlueprint : 1;                  // 0x0A79(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate))
	uint8                                         BitPad_A79_1 : 1;                                  // 0x0A79(0x0001)(Fixing Bit-Field Size Between Bits [ Dumper-7 ])
	uint8                                         bUpdateChildTransformsOnAnimationFinalize : 1;     // 0x0A79(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bUpdateOverlapsOnAnimationFinalize : 1;            // 0x0A79(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         BitPad_A79_4 : 1;                                  // 0x0A79(0x0001)(Fixing Bit-Field Size Between Bits [ Dumper-7 ])
	uint8                                         bHasValidBodies : 1;                               // 0x0A79(0x0001)(BitIndex: 0x05, PropSize: 0x0001 (Transient, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bBlendPhysics : 1;                                 // 0x0A79(0x0001)(BitIndex: 0x06, PropSize: 0x0001 (Transient, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bEnablePhysicsOnDedicatedServer : 1;               // 0x0A79(0x0001)(BitIndex: 0x07, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bUpdateMeshWhenKinematic : 1;                      // 0x0A7A(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bUpdateJointsFromAnimation : 1;                    // 0x0A7A(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bAllowClothActors : 1;                             // 0x0A7A(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bDisableClothSimulation : 1;                       // 0x0A7A(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bUseRealDeltaTime : 1;                             // 0x0A7A(0x0001)(BitIndex: 0x04, PropSize: 0x0001 (Edit, BlueprintVisible, EditConst, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         BitPad_A7A_5 : 3;                                  // 0x0A7A(0x0001)(Fixing Bit-Field Size For New Byte [ Dumper-7 ])
	uint8                                         Pad_A7B[0x5];                                      // 0x0A7B(0x0005)(Fixing Size After Last Property [ Dumper-7 ])
	uint8                                         bDisableRigidBodyAnimNode : 1;                     // 0x0A80(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate))
	uint8                                         bAllowAnimCurveEvaluation : 1;                     // 0x0A80(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPrivate))
	uint8                                         BitPad_A80_2 : 3;                                  // 0x0A80(0x0001)(Fixing Bit-Field Size Between Bits [ Dumper-7 ])
	uint8                                         bCollideWithEnvironment : 1;                       // 0x0A80(0x0001)(BitIndex: 0x05, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bCollideWithAttachedChildren : 1;                  // 0x0A80(0x0001)(BitIndex: 0x06, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bForceCollisionUpdate : 1;                         // 0x0A80(0x0001)(BitIndex: 0x07, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bLocalSpaceSimulation : 1;                         // 0x0A81(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bResetAfterTeleport : 1;                           // 0x0A81(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         BitPad_A81_2 : 1;                                  // 0x0A81(0x0001)(Fixing Bit-Field Size Between Bits [ Dumper-7 ])
	uint8                                         bDeferKinematicBoneUpdate : 1;                     // 0x0A81(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bNoSkeletonUpdate : 1;                             // 0x0A81(0x0001)(BitIndex: 0x04, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bPauseAnims : 1;                                   // 0x0A81(0x0001)(BitIndex: 0x05, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bUseRefPoseOnInitAnim : 1;                         // 0x0A81(0x0001)(BitIndex: 0x06, PropSize: 0x0001 (Edit, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bEnablePerPolyCollision : 1;                       // 0x0A81(0x0001)(BitIndex: 0x07, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bForceRefpose : 1;                                 // 0x0A82(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bOnlyAllowAutonomousTickPose : 1;                  // 0x0A82(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Transient, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bIsAutonomousTickPose : 1;                         // 0x0A82(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Transient, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bOldForceRefPose : 1;                              // 0x0A82(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bShowPrePhysBones : 1;                             // 0x0A82(0x0001)(BitIndex: 0x04, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bRequiredBonesUpToDate : 1;                        // 0x0A82(0x0001)(BitIndex: 0x05, PropSize: 0x0001 (Transient, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bAnimTreeInitialised : 1;                          // 0x0A82(0x0001)(BitIndex: 0x06, PropSize: 0x0001 (Transient, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bIncludeComponentLocationIntoBounds : 1;           // 0x0A82(0x0001)(BitIndex: 0x07, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bEnableLineCheckWithBounds : 1;                    // 0x0A83(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bPropagateCurvesToFollowers : 1;                   // 0x0A83(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bSkipKinematicUpdateWhenInterpolating : 1;         // 0x0A83(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bSkipBoundsUpdateWhenInterpolating : 1;            // 0x0A83(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         BitPad_A83_4 : 2;                                  // 0x0A83(0x0001)(Fixing Bit-Field Size Between Bits [ Dumper-7 ])
	uint8                                         bNeedsQueuedAnimEventsDispatched : 1;              // 0x0A83(0x0001)(BitIndex: 0x06, PropSize: 0x0001 (Transient, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate))
	uint16                                        CachedAnimCurveUidVersion;                         // 0x0A84(0x0002)(ZeroConstructor, Transient, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_A86[0x2];                                      // 0x0A86(0x0002)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         ClothBlendWeight;                                  // 0x0A88(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bWaitForParallelClothTask;                         // 0x0A8C(0x0001)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bFilteredAnimCurvesIsAllowList;                    // 0x0A8D(0x0001)(ZeroConstructor, Transient, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint16                                        CachedMeshCurveMetaDataVersion;                    // 0x0A8E(0x0002)(ZeroConstructor, Transient, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	TArray<class FName>                           FilteredAnimCurves;                                // 0x0A90(0x0010)(ZeroConstructor, Transient, NativeAccessSpecifierPrivate)
	class UBodySetup*                             BodySetup;                                         // 0x0AA0(0x0008)(ZeroConstructor, Transient, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_AA8[0x4];                                      // 0x0AA8(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         ClothMaxDistanceScale;                             // 0x0AAC(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TMulticastInlineDelegate<void(int32 ConstraintIndex)> OnConstraintBroken;                        // 0x0AB0(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	TMulticastInlineDelegate<void(int32 ConstraintIndex)> OnPlasticDeformation;                      // 0x0AC0(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	TSubclassOf<class UClothingSimulationFactory> ClothingSimulationFactory;                         // 0x0AD0(0x0008)(Edit, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_AD8[0x108];                                    // 0x0AD8(0x0108)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         TeleportDistanceThreshold;                         // 0x0BE0(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	float                                         TeleportRotationThreshold;                         // 0x0BE4(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_BE8[0x8];                                      // 0x0BE8(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	uint32                                        LastPoseTickFrame;                                 // 0x0BF0(0x0004)(ZeroConstructor, Transient, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_BF4[0x9C];                                     // 0x0BF4(0x009C)(Fixing Size After Last Property [ Dumper-7 ])
	class UClothingSimulationInteractor*          ClothingInteractor;                                // 0x0C90(0x0008)(ZeroConstructor, Transient, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_C98[0xB8];                                     // 0x0C98(0x00B8)(Fixing Size After Last Property [ Dumper-7 ])
	TMulticastInlineDelegate<void()>              OnAnimInitialized;                                 // 0x0D50(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	uint8                                         Pad_D60[0x258];                                    // 0x0D60(0x0258)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void AccumulateAllBodiesBelowPhysicsBlendWeight(const class FName& InBoneName, float AddPhysicsBlendWeight, bool bSkipCustomPhysicsType);
	void AddForceToAllBodiesBelow(const struct FVector& Force, class FName BoneName, bool bAccelChange, bool bIncludeSelf);
	void AddImpulseToAllBodiesBelow(const struct FVector& Impulse, class FName BoneName, bool bVelChange, bool bIncludeSelf);
	void AllowAnimCurveEvaluation(class FName NameOfCurve, bool bAllow);
	void BindClothToLeaderPoseComponent();
	void BreakConstraint(const struct FVector& Impulse, const struct FVector& HitLocation, class FName InBoneName);
	void ClearMorphTargets();
	class FName FindConstraintBoneName(int32 ConstraintIndex);
	void ForceClothNextUpdateTeleport();
	void ForceClothNextUpdateTeleportAndReset();
	class UClass* GetAnimClass();
	struct FVector GetBoneLinearVelocity(const class FName& InBoneName);
	struct FConstraintInstanceAccessor GetConstraintByName(class FName ConstraintName, bool bIncludesTerminated);
	void GetConstraints(bool bIncludesTerminated, TArray<struct FConstraintInstanceAccessor>* OutConstraints);
	void GetConstraintsFromBody(class FName BodyName, bool bParentConstraints, bool bChildConstraints, bool bIncludesTerminated, TArray<struct FConstraintInstanceAccessor>* OutConstraints);
	void GetCurrentJointAngles(class FName InBoneName, float* Swing1Angle, float* TwistAngle, float* Swing2Angle);
	bool GetFloatAttribute(const class FName& BoneName, const class FName& AttributeName, float DefaultValue, float* OutValue, ECustomBoneAttributeLookup LookupType);
	bool GetFloatAttribute_Ref(const class FName& BoneName, const class FName& AttributeName, float& OutValue, ECustomBoneAttributeLookup LookupType);
	bool GetIntegerAttribute(const class FName& BoneName, const class FName& AttributeName, int32 DefaultValue, int32* OutValue, ECustomBoneAttributeLookup LookupType);
	bool GetIntegerAttribute_Ref(const class FName& BoneName, const class FName& AttributeName, int32& OutValue, ECustomBoneAttributeLookup LookupType);
	bool GetStringAttribute(const class FName& BoneName, const class FName& AttributeName, const class FString& DefaultValue, class FString* OutValue, ECustomBoneAttributeLookup LookupType);
	bool GetStringAttribute_Ref(const class FName& BoneName, const class FName& AttributeName, class FString& OutValue, ECustomBoneAttributeLookup LookupType);
	bool GetTransformAttribute(const class FName& BoneName, const class FName& AttributeName, const struct FTransform& DefaultValue, struct FTransform* OutValue, ECustomBoneAttributeLookup LookupType);
	bool GetTransformAttribute_Ref(const class FName& BoneName, const class FName& AttributeName, struct FTransform& OutValue, ECustomBoneAttributeLookup LookupType);
	bool IsBodyGravityEnabled(class FName BoneName);
	void LinkAnimClassLayers(TSubclassOf<class UAnimInstance> InClass);
	void LinkAnimGraphByTag(class FName InTag, TSubclassOf<class UAnimInstance> InClass);
	void OverrideAnimationData(class UAnimationAsset* InAnimToPlay, bool bIsLooping, bool bIsPlaying, float position, float PlayRate);
	void Play(bool bLooping);
	void PlayAnimation(class UAnimationAsset* NewAnimToPlay, bool bLooping);
	void ResetAllBodiesSimulatePhysics();
	void ResetAllowedAnimCurveEvaluation();
	void ResetAnimInstanceDynamics(ETeleportType InTeleportType);
	void ResetClothTeleportMode();
	void ResumeClothingSimulation();
	void SetAllBodiesBelowLinearVelocity(const class FName& InBoneName, const struct FVector& LinearVelocity, bool bIncludeSelf);
	void SetAllBodiesBelowPhysicsBlendWeight(const class FName& InBoneName, float PhysicsBlendWeight, bool bSkipCustomPhysicsType, bool bIncludeSelf);
	void SetAllBodiesBelowPhysicsDisabled(const class FName& InBoneName, bool bDisabled, bool bIncludeSelf);
	void SetAllBodiesBelowSimulatePhysics(const class FName& InBoneName, bool bNewSimulate, bool bIncludeSelf);
	void SetAllBodiesPhysicsBlendWeight(float PhysicsBlendWeight, bool bSkipCustomPhysicsType);
	void SetAllBodiesSimulatePhysics(bool bNewSimulate);
	void SetAllMotorsAngularDriveParams(float InSpring, float InDamping, float InForceLimit, bool bSkipCustomPhysicsType);
	void SetAllMotorsAngularPositionDrive(bool bEnableSwingDrive, bool bEnableTwistDrive, bool bSkipCustomPhysicsType);
	void SetAllMotorsAngularVelocityDrive(bool bEnableSwingDrive, bool bEnableTwistDrive, bool bSkipCustomPhysicsType);
	void SetAllowAnimCurveEvaluation(bool bInAllow);
	void SetAllowClothActors(bool bInAllow);
	void SetAllowedAnimCurvesEvaluation(const TArray<class FName>& List, bool bAllow);
	void SetAllowRigidBodyAnimNode(bool bInAllow, bool bReinitAnim);
	void SetAngularLimits(class FName InBoneName, float Swing1LimitAngle, float TwistLimitAngle, float Swing2LimitAngle);
	void SetAnimation(class UAnimationAsset* NewAnimToPlay);
	void SetAnimationMode(EAnimationMode InAnimationMode, bool bForceInitAnimScriptInstance);
	void SetAnimClass(class UClass* NewClass);
	void SetBodyNotifyRigidBodyCollision(bool bNewNotifyRigidBodyCollision, class FName BoneName);
	void SetClothMaxDistanceScale(float Scale);
	void SetConstraintProfile(class FName JointName, class FName ProfileName, bool bDefaultIfNotFound);
	void SetConstraintProfileForAll(class FName ProfileName, bool bDefaultIfNotFound);
	void SetDisableAnimCurves(bool bInDisableAnimCurves);
	void SetDisablePostProcessBlueprint(bool bInDisablePostProcess);
	void SetEnableBodyGravity(bool bEnableGravity, class FName BoneName);
	void SetEnableGravityOnAllBodiesBelow(bool bEnableGravity, class FName BoneName, bool bIncludeSelf);
	void SetEnablePhysicsBlending(bool bNewBlendPhysics);
	void SetMorphTarget(class FName MorphTargetName, float Value, bool bRemoveZeroWeight);
	void SetNotifyRigidBodyCollisionBelow(bool bNewNotifyRigidBodyCollision, class FName BoneName, bool bIncludeSelf);
	void SetPhysicsBlendWeight(float PhysicsBlendWeight);
	void SetPlayRate(float Rate);
	void SetPosition(float InPos, bool bFireNotifies);
	void SetSkeletalMeshAsset(class USkeletalMesh* NewMesh);
	void SetTeleportDistanceThreshold(float Threshold);
	void SetTeleportRotationThreshold(float Threshold);
	void SetUpdateAnimationInEditor(const bool NewUpdateState);
	void SetUpdateClothInEditor(const bool NewUpdateState);
	void SnapshotPose(struct FPoseSnapshot& Snapshot);
	void Stop();
	void SuspendClothingSimulation();
	void TermBodiesBelow(class FName ParentBoneName);
	void ToggleDisablePostProcessBlueprint();
	void UnbindClothFromLeaderPoseComponent(bool bRestoreSimulationSpace);
	void UnlinkAnimClassLayers(TSubclassOf<class UAnimInstance> InClass);

	bool GetAllowClothActors() const;
	bool GetAllowedAnimCurveEvaluate() const;
	bool GetAllowRigidBodyAnimNode() const;
	EAnimationMode GetAnimationMode() const;
	class UAnimInstance* GetAnimInstance() const;
	float GetBoneMass(class FName BoneName, bool bScaleMass) const;
	class UClothingSimulationInteractor* GetClothingSimulationInteractor() const;
	float GetClothMaxDistanceScale() const;
	bool GetDisableAnimCurves() const;
	bool GetDisablePostProcessBlueprint() const;
	class UAnimInstance* GetLinkedAnimGraphInstanceByTag(class FName InTag) const;
	void GetLinkedAnimGraphInstancesByTag(class FName InTag, TArray<class UAnimInstance*>* OutLinkedInstances) const;
	class UAnimInstance* GetLinkedAnimLayerInstanceByClass(TSubclassOf<class UAnimInstance> InClass) const;
	class UAnimInstance* GetLinkedAnimLayerInstanceByGroup(class FName InGroup) const;
	float GetMorphTarget(class FName MorphTargetName) const;
	float GetPlayRate() const;
	float GetPosition() const;
	class UAnimInstance* GetPostProcessInstance() const;
	struct FVector GetSkeletalCenterOfMass() const;
	class USkeletalMesh* GetSkeletalMeshAsset() const;
	float GetTeleportDistanceThreshold() const;
	float GetTeleportRotationThreshold() const;
	bool HasValidAnimationInstance() const;
	bool IsClothingSimulationSuspended() const;
	bool IsPlaying() const;
	bool K2_GetClosestPointOnPhysicsAsset(const struct FVector& WorldPosition, struct FVector* ClosestWorldPosition, struct FVector* Normal, class FName* BoneName, float* Distance) const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"SkeletalMeshComponent">();
	}
	static class USkeletalMeshComponent* GetDefaultObj()
	{
		return GetDefaultObjImpl<USkeletalMeshComponent>();
	}
};
#pragma pack(pop)
static_assert(alignof(USkeletalMeshComponent) == 0x000010, "Wrong alignment on USkeletalMeshComponent");
static_assert(sizeof(USkeletalMeshComponent) == 0x000FC0, "Wrong size on USkeletalMeshComponent");
static_assert(offsetof(USkeletalMeshComponent, SkeletalMeshAsset) == 0x0008F0, "Member 'USkeletalMeshComponent::SkeletalMeshAsset' has a wrong offset!");
static_assert(offsetof(USkeletalMeshComponent, AnimBlueprintGeneratedClass) == 0x0008F8, "Member 'USkeletalMeshComponent::AnimBlueprintGeneratedClass' has a wrong offset!");
static_assert(offsetof(USkeletalMeshComponent, AnimClass) == 0x000900, "Member 'USkeletalMeshComponent::AnimClass' has a wrong offset!");
static_assert(offsetof(USkeletalMeshComponent, AnimScriptInstance) == 0x000908, "Member 'USkeletalMeshComponent::AnimScriptInstance' has a wrong offset!");
static_assert(offsetof(USkeletalMeshComponent, PostProcessAnimInstance) == 0x000910, "Member 'USkeletalMeshComponent::PostProcessAnimInstance' has a wrong offset!");
static_assert(offsetof(USkeletalMeshComponent, AnimationData) == 0x000918, "Member 'USkeletalMeshComponent::AnimationData' has a wrong offset!");
static_assert(offsetof(USkeletalMeshComponent, RootBoneTranslation) == 0x000940, "Member 'USkeletalMeshComponent::RootBoneTranslation' has a wrong offset!");
static_assert(offsetof(USkeletalMeshComponent, LineCheckBoundsScale) == 0x000958, "Member 'USkeletalMeshComponent::LineCheckBoundsScale' has a wrong offset!");
static_assert(offsetof(USkeletalMeshComponent, LinkedInstances) == 0x000990, "Member 'USkeletalMeshComponent::LinkedInstances' has a wrong offset!");
static_assert(offsetof(USkeletalMeshComponent, CachedBoneSpaceTransforms) == 0x0009B0, "Member 'USkeletalMeshComponent::CachedBoneSpaceTransforms' has a wrong offset!");
static_assert(offsetof(USkeletalMeshComponent, CachedComponentSpaceTransforms) == 0x0009C0, "Member 'USkeletalMeshComponent::CachedComponentSpaceTransforms' has a wrong offset!");
static_assert(offsetof(USkeletalMeshComponent, GlobalAnimRateScale) == 0x000A70, "Member 'USkeletalMeshComponent::GlobalAnimRateScale' has a wrong offset!");
static_assert(offsetof(USkeletalMeshComponent, KinematicBonesUpdateType) == 0x000A74, "Member 'USkeletalMeshComponent::KinematicBonesUpdateType' has a wrong offset!");
static_assert(offsetof(USkeletalMeshComponent, PhysicsTransformUpdateMode) == 0x000A75, "Member 'USkeletalMeshComponent::PhysicsTransformUpdateMode' has a wrong offset!");
static_assert(offsetof(USkeletalMeshComponent, AnimationMode) == 0x000A77, "Member 'USkeletalMeshComponent::AnimationMode' has a wrong offset!");
static_assert(offsetof(USkeletalMeshComponent, CachedAnimCurveUidVersion) == 0x000A84, "Member 'USkeletalMeshComponent::CachedAnimCurveUidVersion' has a wrong offset!");
static_assert(offsetof(USkeletalMeshComponent, ClothBlendWeight) == 0x000A88, "Member 'USkeletalMeshComponent::ClothBlendWeight' has a wrong offset!");
static_assert(offsetof(USkeletalMeshComponent, bWaitForParallelClothTask) == 0x000A8C, "Member 'USkeletalMeshComponent::bWaitForParallelClothTask' has a wrong offset!");
static_assert(offsetof(USkeletalMeshComponent, bFilteredAnimCurvesIsAllowList) == 0x000A8D, "Member 'USkeletalMeshComponent::bFilteredAnimCurvesIsAllowList' has a wrong offset!");
static_assert(offsetof(USkeletalMeshComponent, CachedMeshCurveMetaDataVersion) == 0x000A8E, "Member 'USkeletalMeshComponent::CachedMeshCurveMetaDataVersion' has a wrong offset!");
static_assert(offsetof(USkeletalMeshComponent, FilteredAnimCurves) == 0x000A90, "Member 'USkeletalMeshComponent::FilteredAnimCurves' has a wrong offset!");
static_assert(offsetof(USkeletalMeshComponent, BodySetup) == 0x000AA0, "Member 'USkeletalMeshComponent::BodySetup' has a wrong offset!");
static_assert(offsetof(USkeletalMeshComponent, ClothMaxDistanceScale) == 0x000AAC, "Member 'USkeletalMeshComponent::ClothMaxDistanceScale' has a wrong offset!");
static_assert(offsetof(USkeletalMeshComponent, OnConstraintBroken) == 0x000AB0, "Member 'USkeletalMeshComponent::OnConstraintBroken' has a wrong offset!");
static_assert(offsetof(USkeletalMeshComponent, OnPlasticDeformation) == 0x000AC0, "Member 'USkeletalMeshComponent::OnPlasticDeformation' has a wrong offset!");
static_assert(offsetof(USkeletalMeshComponent, ClothingSimulationFactory) == 0x000AD0, "Member 'USkeletalMeshComponent::ClothingSimulationFactory' has a wrong offset!");
static_assert(offsetof(USkeletalMeshComponent, TeleportDistanceThreshold) == 0x000BE0, "Member 'USkeletalMeshComponent::TeleportDistanceThreshold' has a wrong offset!");
static_assert(offsetof(USkeletalMeshComponent, TeleportRotationThreshold) == 0x000BE4, "Member 'USkeletalMeshComponent::TeleportRotationThreshold' has a wrong offset!");
static_assert(offsetof(USkeletalMeshComponent, LastPoseTickFrame) == 0x000BF0, "Member 'USkeletalMeshComponent::LastPoseTickFrame' has a wrong offset!");
static_assert(offsetof(USkeletalMeshComponent, ClothingInteractor) == 0x000C90, "Member 'USkeletalMeshComponent::ClothingInteractor' has a wrong offset!");
static_assert(offsetof(USkeletalMeshComponent, OnAnimInitialized) == 0x000D50, "Member 'USkeletalMeshComponent::OnAnimInitialized' has a wrong offset!");

// Class Engine.MaterialExpressionSetMaterialAttributes
// 0x0020 (0x00D0 - 0x00B0)
class UMaterialExpressionSetMaterialAttributes final : public UMaterialExpression
{
public:
	TArray<struct FExpressionInput>               Inputs;                                            // 0x00B0(0x0010)(ZeroConstructor, NativeAccessSpecifierPublic)
	TArray<struct FGuid>                          AttributeSetTypes;                                 // 0x00C0(0x0010)(Edit, ZeroConstructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionSetMaterialAttributes">();
	}
	static class UMaterialExpressionSetMaterialAttributes* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionSetMaterialAttributes>();
	}
};
static_assert(alignof(UMaterialExpressionSetMaterialAttributes) == 0x000008, "Wrong alignment on UMaterialExpressionSetMaterialAttributes");
static_assert(sizeof(UMaterialExpressionSetMaterialAttributes) == 0x0000D0, "Wrong size on UMaterialExpressionSetMaterialAttributes");
static_assert(offsetof(UMaterialExpressionSetMaterialAttributes, Inputs) == 0x0000B0, "Member 'UMaterialExpressionSetMaterialAttributes::Inputs' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionSetMaterialAttributes, AttributeSetTypes) == 0x0000C0, "Member 'UMaterialExpressionSetMaterialAttributes::AttributeSetTypes' has a wrong offset!");

// Class Engine.AnimInstance
// 0x0328 (0x0350 - 0x0028)
#pragma pack(push, 0x1)
class alignas(0x10) UAnimInstance : public UObject
{
public:
	class USkeleton*                              CurrentSkeleton;                                   // 0x0028(0x0008)(ZeroConstructor, Transient, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	ERootMotionMode                               RootMotionMode;                                    // 0x0030(0x0001)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bUseMultiThreadedAnimationUpdate : 1;              // 0x0031(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bUsingCopyPoseFromMesh : 1;                        // 0x0031(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         BitPad_31_2 : 2;                                   // 0x0031(0x0001)(Fixing Bit-Field Size Between Bits [ Dumper-7 ])
	uint8                                         bReceiveNotifiesFromLinkedInstances : 1;           // 0x0031(0x0001)(BitIndex: 0x04, PropSize: 0x0001 (Edit, DisableEditOnInstance, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bPropagateNotifiesToLinkedInstances : 1;           // 0x0031(0x0001)(BitIndex: 0x05, PropSize: 0x0001 (Edit, DisableEditOnInstance, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bUseMainInstanceMontageEvaluationData : 1;         // 0x0031(0x0001)(BitIndex: 0x06, PropSize: 0x0001 (Edit, DisableEditOnInstance, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bQueueMontageEvents : 1;                           // 0x0031(0x0001)(BitIndex: 0x07, PropSize: 0x0001 (Transient, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate))
	uint8                                         Pad_32[0x6];                                       // 0x0032(0x0006)(Fixing Size After Last Property [ Dumper-7 ])
	TMulticastInlineDelegate<void(class UAnimMontage* Montage, bool bInterrupted)> OnMontageBlendingOut; // 0x0038(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	TMulticastInlineDelegate<void(class UAnimMontage* Montage)> OnMontageStarted;                    // 0x0048(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	TMulticastInlineDelegate<void(class UAnimMontage* Montage, bool bInterrupted)> OnMontageEnded;   // 0x0058(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	TMulticastInlineDelegate<void()>              OnAllMontageInstancesEnded;                        // 0x0068(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	uint8                                         Pad_78[0xD8];                                      // 0x0078(0x00D8)(Fixing Size After Last Property [ Dumper-7 ])
	struct FAnimNotifyQueue                       NotifyQueue;                                       // 0x0150(0x0070)(Transient, NativeAccessSpecifierPublic)
	TArray<struct FAnimNotifyEvent>               ActiveAnimNotifyState;                             // 0x01C0(0x0010)(ZeroConstructor, Transient, ContainsInstancedReference, NativeAccessSpecifierPublic)
	TArray<struct FAnimNotifyEventReference>      ActiveAnimNotifyEventReference;                    // 0x01D0(0x0010)(ZeroConstructor, Transient, NativeAccessSpecifierPublic)
	uint8                                         Pad_1E0[0x168];                                    // 0x01E0(0x0168)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void BlueprintBeginPlay();
	void BlueprintInitializeAnimation();
	void BlueprintLinkedAnimationLayersInitialized();
	void BlueprintPostEvaluateAnimation();
	void BlueprintThreadSafeUpdateAnimation(float DeltaTime);
	void BlueprintUpdateAnimation(float DeltaTimeX);
	void ClearAllTransitionEvents();
	void ClearMorphTargets();
	void ClearTransitionEvents(const class FName EventName);
	class FName GetCurrentStateName(int32 MachineIndex);
	bool GetCurveValueWithDefault(class FName CurveName, float DefaultValue, float* OutValue);
	float GetInstanceAssetPlayerLength(int32 AssetPlayerIndex);
	float GetInstanceAssetPlayerTime(int32 AssetPlayerIndex);
	float GetInstanceAssetPlayerTimeFraction(int32 AssetPlayerIndex);
	float GetInstanceAssetPlayerTimeFromEnd(int32 AssetPlayerIndex);
	float GetInstanceAssetPlayerTimeFromEndFraction(int32 AssetPlayerIndex);
	float GetInstanceCurrentStateElapsedTime(int32 MachineIndex);
	float GetInstanceMachineWeight(int32 MachineIndex);
	float GetInstanceStateWeight(int32 MachineIndex, int32 StateIndex);
	float GetInstanceTransitionCrossfadeDuration(int32 MachineIndex, int32 TransitionIndex);
	float GetInstanceTransitionTimeElapsed(int32 MachineIndex, int32 TransitionIndex);
	float GetInstanceTransitionTimeElapsedFraction(int32 MachineIndex, int32 TransitionIndex);
	float GetRelevantAnimLength(int32 MachineIndex, int32 StateIndex);
	float GetRelevantAnimTime(int32 MachineIndex, int32 StateIndex);
	float GetRelevantAnimTimeFraction(int32 MachineIndex, int32 StateIndex);
	float GetRelevantAnimTimeRemaining(int32 MachineIndex, int32 StateIndex);
	float GetRelevantAnimTimeRemainingFraction(int32 MachineIndex, int32 StateIndex);
	void LinkAnimClassLayers(TSubclassOf<class UAnimInstance> InClass);
	void LinkAnimGraphByTag(class FName InTag, TSubclassOf<class UAnimInstance> InClass);
	void LockAIResources(bool bLockMovement, bool LockAILogic);
	void Montage_JumpToSection(class FName SectionName, const class UAnimMontage* Montage);
	void Montage_JumpToSectionsEnd(class FName SectionName, const class UAnimMontage* Montage);
	void Montage_Pause(const class UAnimMontage* Montage);
	float Montage_Play(class UAnimMontage* MontageToPlay, float InPlayRate, EMontagePlayReturnType ReturnValueType, float InTimeToStartMontageAt, bool bStopAllMontages);
	float Montage_PlayWithBlendIn(class UAnimMontage* MontageToPlay, const struct FAlphaBlendArgs& BlendIn, float InPlayRate, EMontagePlayReturnType ReturnValueType, float InTimeToStartMontageAt, bool bStopAllMontages);
	float Montage_PlayWithBlendSettings(class UAnimMontage* MontageToPlay, const struct FMontageBlendSettings& BlendInSettings, float InPlayRate, EMontagePlayReturnType ReturnValueType, float InTimeToStartMontageAt, bool bStopAllMontages);
	void Montage_Resume(const class UAnimMontage* Montage);
	void Montage_SetNextSection(class FName SectionNameToChange, class FName NextSection, const class UAnimMontage* Montage);
	void Montage_SetPlayRate(const class UAnimMontage* Montage, float NewPlayRate);
	void Montage_SetPosition(const class UAnimMontage* Montage, float NewPosition);
	void Montage_Stop(float InBlendOutTime, const class UAnimMontage* Montage);
	void Montage_StopGroupByName(float InBlendOutTime, class FName GroupName);
	void Montage_StopWithBlendOut(const struct FAlphaBlendArgs& BlendOut, const class UAnimMontage* Montage);
	void Montage_StopWithBlendSettings(const struct FMontageBlendSettings& BlendOutSettings, const class UAnimMontage* Montage);
	void MontageSync_Follow(const class UAnimMontage* MontageFollower, const class UAnimInstance* OtherAnimInstance, const class UAnimMontage* MontageLeader);
	void MontageSync_StopFollowing(const class UAnimMontage* MontageFollower);
	class UAnimMontage* PlaySlotAnimationAsDynamicMontage(class UAnimSequenceBase* Asset, class FName SlotNodeName, float BlendInTime, float BlendOutTime, float InPlayRate, int32 LoopCount, float BlendOutTriggerTime, float InTimeToStartMontageAt);
	class UAnimMontage* PlaySlotAnimationAsDynamicMontage_WithBlendArgs(class UAnimSequenceBase* Asset, class FName SlotNodeName, const struct FAlphaBlendArgs& BlendIn, const struct FAlphaBlendArgs& BlendOut, float InPlayRate, int32 LoopCount, float BlendOutTriggerTime, float InTimeToStartMontageAt);
	class UAnimMontage* PlaySlotAnimationAsDynamicMontage_WithBlendSettings(class UAnimSequenceBase* Asset, class FName SlotNodeName, const struct FMontageBlendSettings& BlendInSettings, const struct FMontageBlendSettings& BlendOutSettings, float InPlayRate, int32 LoopCount, float BlendOutTriggerTime, float InTimeToStartMontageAt);
	bool QueryAndMarkTransitionEvent(int32 MachineIndex, int32 TransitionIndex, class FName EventName);
	bool QueryTransitionEvent(int32 MachineIndex, int32 TransitionIndex, class FName EventName);
	void RemovePoseSnapshot(class FName SnapshotName);
	void RequestSlotGroupInertialization(class FName InSlotGroupName, float Duration, const class UBlendProfile* BlendProfile);
	bool RequestTransitionEvent(const class FName EventName, const double RequestTimeout, const ETransitionRequestQueueMode QueueMode, const ETransitionRequestOverwriteMode OverwriteMode);
	void ResetDynamics(ETeleportType InTeleportType);
	void SavePoseSnapshot(class FName SnapshotName);
	void SetMorphTarget(class FName MorphTargetName, float Value);
	void SetPropagateNotifiesToLinkedInstances(bool bSet);
	void SetReceiveNotifiesFromLinkedInstances(bool bSet);
	void SetRootMotionMode(ERootMotionMode Value);
	void SetUseMainInstanceMontageEvaluationData(bool bSet);
	void SnapshotPose(struct FPoseSnapshot& Snapshot);
	void StopSlotAnimation(float InBlendOutTime, class FName SlotNodeName);
	void UnlinkAnimClassLayers(TSubclassOf<class UAnimInstance> InClass);
	void UnlockAIResources(bool bUnlockMovement, bool UnlockAILogic);
	bool WasAnimNotifyNameTriggeredInAnyState(class FName NotifyName);
	bool WasAnimNotifyNameTriggeredInSourceState(int32 MachineIndex, int32 StateIndex, class FName NotifyName);
	bool WasAnimNotifyNameTriggeredInStateMachine(int32 MachineIndex, class FName NotifyName);
	bool WasAnimNotifyStateActiveInAnyState(TSubclassOf<class UAnimNotifyState> AnimNotifyStateType);
	bool WasAnimNotifyStateActiveInSourceState(int32 MachineIndex, int32 StateIndex, TSubclassOf<class UAnimNotifyState> AnimNotifyStateType);
	bool WasAnimNotifyStateActiveInStateMachine(int32 MachineIndex, TSubclassOf<class UAnimNotifyState> AnimNotifyStateType);
	bool WasAnimNotifyTriggeredInAnyState(TSubclassOf<class UAnimNotify> AnimNotifyType);
	bool WasAnimNotifyTriggeredInSourceState(int32 MachineIndex, int32 StateIndex, TSubclassOf<class UAnimNotify> AnimNotifyType);
	bool WasAnimNotifyTriggeredInStateMachine(int32 MachineIndex, TSubclassOf<class UAnimNotify> AnimNotifyType);

	float Blueprint_GetSlotMontageLocalWeight(class FName SlotNodeName) const;
	float CalculateDirection(const struct FVector& Velocity, const struct FRotator& BaseRotation) const;
	void GetActiveCurveNames(EAnimCurveType CurveType, TArray<class FName>* OutNames) const;
	void GetAllCurveNames(TArray<class FName>* OutNames) const;
	class UAnimMontage* GetCurrentActiveMontage() const;
	float GetCurveValue(class FName CurveName) const;
	float GetDeltaSeconds() const;
	class UAnimInstance* GetLinkedAnimGraphInstanceByTag(class FName InTag) const;
	void GetLinkedAnimGraphInstancesByTag(class FName InTag, TArray<class UAnimInstance*>* OutLinkedInstances) const;
	class UAnimInstance* GetLinkedAnimLayerInstanceByClass(TSubclassOf<class UAnimInstance> InClass) const;
	class UAnimInstance* GetLinkedAnimLayerInstanceByGroup(class FName InGroup) const;
	class UAnimInstance* GetLinkedAnimLayerInstanceByGroupAndClass(class FName InGroup, TSubclassOf<class UAnimInstance> InClass) const;
	void GetLinkedAnimLayerInstancesByGroup(class FName InGroup, TArray<class UAnimInstance*>* OutLinkedInstances) const;
	class AActor* GetOwningActor() const;
	class USkeletalMeshComponent* GetOwningComponent() const;
	bool GetPropagateNotifiesToLinkedInstances() const;
	bool GetReceiveNotifiesFromLinkedInstances() const;
	struct FMarkerSyncAnimPosition GetSyncGroupPosition(class FName InSyncGroupName) const;
	bool GetTimeToClosestMarker(class FName SyncGroup, class FName MarkerName, float* OutMarkerTime) const;
	bool HasMarkerBeenHitThisFrame(class FName SyncGroup, class FName MarkerName) const;
	bool IsAnyMontagePlaying() const;
	bool IsPlayingSlotAnimation(const class UAnimSequenceBase* Asset, class FName SlotNodeName) const;
	bool IsSlotActive(class FName SlotNodeName) const;
	bool IsSyncGroupBetweenMarkers(class FName InSyncGroupName, class FName PreviousMarker, class FName NextMarker, bool bRespectMarkerOrder) const;
	bool IsUsingMainInstanceMontageEvaluationData() const;
	float Montage_GetBlendTime(const class UAnimMontage* Montage) const;
	class FName Montage_GetCurrentSection(const class UAnimMontage* Montage) const;
	float Montage_GetEffectivePlayRate(const class UAnimMontage* Montage) const;
	bool Montage_GetIsStopped(const class UAnimMontage* Montage) const;
	float Montage_GetPlayRate(const class UAnimMontage* Montage) const;
	float Montage_GetPosition(const class UAnimMontage* Montage) const;
	bool Montage_IsActive(const class UAnimMontage* Montage) const;
	bool Montage_IsPlaying(const class UAnimMontage* Montage) const;
	class APawn* TryGetPawnOwner() const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AnimInstance">();
	}
	static class UAnimInstance* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAnimInstance>();
	}
};
#pragma pack(pop)
static_assert(alignof(UAnimInstance) == 0x000010, "Wrong alignment on UAnimInstance");
static_assert(sizeof(UAnimInstance) == 0x000350, "Wrong size on UAnimInstance");
static_assert(offsetof(UAnimInstance, CurrentSkeleton) == 0x000028, "Member 'UAnimInstance::CurrentSkeleton' has a wrong offset!");
static_assert(offsetof(UAnimInstance, RootMotionMode) == 0x000030, "Member 'UAnimInstance::RootMotionMode' has a wrong offset!");
static_assert(offsetof(UAnimInstance, OnMontageBlendingOut) == 0x000038, "Member 'UAnimInstance::OnMontageBlendingOut' has a wrong offset!");
static_assert(offsetof(UAnimInstance, OnMontageStarted) == 0x000048, "Member 'UAnimInstance::OnMontageStarted' has a wrong offset!");
static_assert(offsetof(UAnimInstance, OnMontageEnded) == 0x000058, "Member 'UAnimInstance::OnMontageEnded' has a wrong offset!");
static_assert(offsetof(UAnimInstance, OnAllMontageInstancesEnded) == 0x000068, "Member 'UAnimInstance::OnAllMontageInstancesEnded' has a wrong offset!");
static_assert(offsetof(UAnimInstance, NotifyQueue) == 0x000150, "Member 'UAnimInstance::NotifyQueue' has a wrong offset!");
static_assert(offsetof(UAnimInstance, ActiveAnimNotifyState) == 0x0001C0, "Member 'UAnimInstance::ActiveAnimNotifyState' has a wrong offset!");
static_assert(offsetof(UAnimInstance, ActiveAnimNotifyEventReference) == 0x0001D0, "Member 'UAnimInstance::ActiveAnimNotifyEventReference' has a wrong offset!");

// Class Engine.LevelScriptBlueprint
// 0x0000 (0x00A8 - 0x00A8)
class ULevelScriptBlueprint final : public UBlueprint
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"LevelScriptBlueprint">();
	}
	static class ULevelScriptBlueprint* GetDefaultObj()
	{
		return GetDefaultObjImpl<ULevelScriptBlueprint>();
	}
};
static_assert(alignof(ULevelScriptBlueprint) == 0x000008, "Wrong alignment on ULevelScriptBlueprint");
static_assert(sizeof(ULevelScriptBlueprint) == 0x0000A8, "Wrong size on ULevelScriptBlueprint");

// Class Engine.Interface_AssetUserData
// 0x0000 (0x0000 - 0x0000)
class IInterface_AssetUserData final
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"Interface_AssetUserData">();
	}
	static class IInterface_AssetUserData* GetDefaultObj()
	{
		return GetDefaultObjImpl<IInterface_AssetUserData>();
	}

	class UObject* AsUObject()
	{
		return reinterpret_cast<UObject*>(this);
	}
	const class UObject* AsUObject() const
	{
		return reinterpret_cast<const UObject*>(this);
	}
};
static_assert(alignof(IInterface_AssetUserData) == 0x000001, "Wrong alignment on IInterface_AssetUserData");
static_assert(sizeof(IInterface_AssetUserData) == 0x000001, "Wrong size on IInterface_AssetUserData");

// Class Engine.DataAsset
// 0x0008 (0x0030 - 0x0028)
class UDataAsset : public UObject
{
public:
	TSubclassOf<class UDataAsset>                 NativeClass;                                       // 0x0028(0x0008)(ZeroConstructor, NoDestructor, AssetRegistrySearchable, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"DataAsset">();
	}
	static class UDataAsset* GetDefaultObj()
	{
		return GetDefaultObjImpl<UDataAsset>();
	}
};
static_assert(alignof(UDataAsset) == 0x000008, "Wrong alignment on UDataAsset");
static_assert(sizeof(UDataAsset) == 0x000030, "Wrong size on UDataAsset");
static_assert(offsetof(UDataAsset, NativeClass) == 0x000028, "Member 'UDataAsset::NativeClass' has a wrong offset!");

// Class Engine.PrimaryDataAsset
// 0x0000 (0x0030 - 0x0030)
class UPrimaryDataAsset : public UDataAsset
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"PrimaryDataAsset">();
	}
	static class UPrimaryDataAsset* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPrimaryDataAsset>();
	}
};
static_assert(alignof(UPrimaryDataAsset) == 0x000008, "Wrong alignment on UPrimaryDataAsset");
static_assert(sizeof(UPrimaryDataAsset) == 0x000030, "Wrong size on UPrimaryDataAsset");

// Class Engine.BlueprintAsyncActionBase
// 0x0008 (0x0030 - 0x0028)
class UBlueprintAsyncActionBase : public UObject
{
public:
	uint8                                         Pad_28[0x8];                                       // 0x0028(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void Activate();

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"BlueprintAsyncActionBase">();
	}
	static class UBlueprintAsyncActionBase* GetDefaultObj()
	{
		return GetDefaultObjImpl<UBlueprintAsyncActionBase>();
	}
};
static_assert(alignof(UBlueprintAsyncActionBase) == 0x000008, "Wrong alignment on UBlueprintAsyncActionBase");
static_assert(sizeof(UBlueprintAsyncActionBase) == 0x000030, "Wrong size on UBlueprintAsyncActionBase");

// Class Engine.EngineSubsystem
// 0x0000 (0x0030 - 0x0030)
class UEngineSubsystem : public UDynamicSubsystem
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"EngineSubsystem">();
	}
	static class UEngineSubsystem* GetDefaultObj()
	{
		return GetDefaultObjImpl<UEngineSubsystem>();
	}
};
static_assert(alignof(UEngineSubsystem) == 0x000008, "Wrong alignment on UEngineSubsystem");
static_assert(sizeof(UEngineSubsystem) == 0x000030, "Wrong size on UEngineSubsystem");

// Class Engine.ServerStatReplicator
// 0x00C8 (0x0368 - 0x02A0)
class AServerStatReplicator final : public AInfo
{
public:
	bool                                          bUpdateStatNet;                                    // 0x02A0(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bOverwriteClientStats;                             // 0x02A1(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_2A2[0x2];                                      // 0x02A2(0x0002)(Fixing Size After Last Property [ Dumper-7 ])
	uint32                                        Channels;                                          // 0x02A4(0x0004)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint32                                        InRate;                                            // 0x02A8(0x0004)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint32                                        OutRate;                                           // 0x02AC(0x0004)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_2B0[0x4];                                      // 0x02B0(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	uint32                                        MaxPacketOverhead;                                 // 0x02B4(0x0004)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint32                                        InRateClientMax;                                   // 0x02B8(0x0004)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint32                                        InRateClientMin;                                   // 0x02BC(0x0004)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint32                                        InRateClientAvg;                                   // 0x02C0(0x0004)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint32                                        InPacketsClientMax;                                // 0x02C4(0x0004)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint32                                        InPacketsClientMin;                                // 0x02C8(0x0004)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint32                                        InPacketsClientAvg;                                // 0x02CC(0x0004)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint32                                        OutRateClientMax;                                  // 0x02D0(0x0004)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint32                                        OutRateClientMin;                                  // 0x02D4(0x0004)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint32                                        OutRateClientAvg;                                  // 0x02D8(0x0004)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint32                                        OutPacketsClientMax;                               // 0x02DC(0x0004)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint32                                        OutPacketsClientMin;                               // 0x02E0(0x0004)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint32                                        OutPacketsClientAvg;                               // 0x02E4(0x0004)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint32                                        NetNumClients;                                     // 0x02E8(0x0004)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint32                                        InPackets;                                         // 0x02EC(0x0004)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint32                                        OutPackets;                                        // 0x02F0(0x0004)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint32                                        InBunches;                                         // 0x02F4(0x0004)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint32                                        OutBunches;                                        // 0x02F8(0x0004)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint32                                        OutLoss;                                           // 0x02FC(0x0004)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint32                                        InLoss;                                            // 0x0300(0x0004)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint32                                        VoiceBytesSent;                                    // 0x0304(0x0004)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint32                                        VoiceBytesRecv;                                    // 0x0308(0x0004)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint32                                        VoicePacketsSent;                                  // 0x030C(0x0004)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint32                                        VoicePacketsRecv;                                  // 0x0310(0x0004)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint32                                        PercentInVoice;                                    // 0x0314(0x0004)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint32                                        PercentOutVoice;                                   // 0x0318(0x0004)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint32                                        NumActorChannels;                                  // 0x031C(0x0004)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint32                                        NumConsideredActors;                               // 0x0320(0x0004)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint32                                        PrioritizedActors;                                 // 0x0324(0x0004)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint32                                        NumRelevantActors;                                 // 0x0328(0x0004)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint32                                        NumRelevantDeletedActors;                          // 0x032C(0x0004)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint32                                        NumReplicatedActorAttempts;                        // 0x0330(0x0004)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint32                                        NumReplicatedActors;                               // 0x0334(0x0004)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint32                                        NumActors;                                         // 0x0338(0x0004)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint32                                        NumNetActors;                                      // 0x033C(0x0004)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint32                                        NumDormantActors;                                  // 0x0340(0x0004)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint32                                        NumInitiallyDormantActors;                         // 0x0344(0x0004)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint32                                        NumNetGUIDsAckd;                                   // 0x0348(0x0004)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint32                                        NumNetGUIDsPending;                                // 0x034C(0x0004)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint32                                        NumNetGUIDsUnAckd;                                 // 0x0350(0x0004)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint32                                        ObjPathBytes;                                      // 0x0354(0x0004)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint32                                        NetGUIDOutRate;                                    // 0x0358(0x0004)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint32                                        NetGUIDInRate;                                     // 0x035C(0x0004)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint32                                        NetSaturated;                                      // 0x0360(0x0004)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_364[0x4];                                      // 0x0364(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ServerStatReplicator">();
	}
	static class AServerStatReplicator* GetDefaultObj()
	{
		return GetDefaultObjImpl<AServerStatReplicator>();
	}
};
static_assert(alignof(AServerStatReplicator) == 0x000008, "Wrong alignment on AServerStatReplicator");
static_assert(sizeof(AServerStatReplicator) == 0x000368, "Wrong size on AServerStatReplicator");
static_assert(offsetof(AServerStatReplicator, bUpdateStatNet) == 0x0002A0, "Member 'AServerStatReplicator::bUpdateStatNet' has a wrong offset!");
static_assert(offsetof(AServerStatReplicator, bOverwriteClientStats) == 0x0002A1, "Member 'AServerStatReplicator::bOverwriteClientStats' has a wrong offset!");
static_assert(offsetof(AServerStatReplicator, Channels) == 0x0002A4, "Member 'AServerStatReplicator::Channels' has a wrong offset!");
static_assert(offsetof(AServerStatReplicator, InRate) == 0x0002A8, "Member 'AServerStatReplicator::InRate' has a wrong offset!");
static_assert(offsetof(AServerStatReplicator, OutRate) == 0x0002AC, "Member 'AServerStatReplicator::OutRate' has a wrong offset!");
static_assert(offsetof(AServerStatReplicator, MaxPacketOverhead) == 0x0002B4, "Member 'AServerStatReplicator::MaxPacketOverhead' has a wrong offset!");
static_assert(offsetof(AServerStatReplicator, InRateClientMax) == 0x0002B8, "Member 'AServerStatReplicator::InRateClientMax' has a wrong offset!");
static_assert(offsetof(AServerStatReplicator, InRateClientMin) == 0x0002BC, "Member 'AServerStatReplicator::InRateClientMin' has a wrong offset!");
static_assert(offsetof(AServerStatReplicator, InRateClientAvg) == 0x0002C0, "Member 'AServerStatReplicator::InRateClientAvg' has a wrong offset!");
static_assert(offsetof(AServerStatReplicator, InPacketsClientMax) == 0x0002C4, "Member 'AServerStatReplicator::InPacketsClientMax' has a wrong offset!");
static_assert(offsetof(AServerStatReplicator, InPacketsClientMin) == 0x0002C8, "Member 'AServerStatReplicator::InPacketsClientMin' has a wrong offset!");
static_assert(offsetof(AServerStatReplicator, InPacketsClientAvg) == 0x0002CC, "Member 'AServerStatReplicator::InPacketsClientAvg' has a wrong offset!");
static_assert(offsetof(AServerStatReplicator, OutRateClientMax) == 0x0002D0, "Member 'AServerStatReplicator::OutRateClientMax' has a wrong offset!");
static_assert(offsetof(AServerStatReplicator, OutRateClientMin) == 0x0002D4, "Member 'AServerStatReplicator::OutRateClientMin' has a wrong offset!");
static_assert(offsetof(AServerStatReplicator, OutRateClientAvg) == 0x0002D8, "Member 'AServerStatReplicator::OutRateClientAvg' has a wrong offset!");
static_assert(offsetof(AServerStatReplicator, OutPacketsClientMax) == 0x0002DC, "Member 'AServerStatReplicator::OutPacketsClientMax' has a wrong offset!");
static_assert(offsetof(AServerStatReplicator, OutPacketsClientMin) == 0x0002E0, "Member 'AServerStatReplicator::OutPacketsClientMin' has a wrong offset!");
static_assert(offsetof(AServerStatReplicator, OutPacketsClientAvg) == 0x0002E4, "Member 'AServerStatReplicator::OutPacketsClientAvg' has a wrong offset!");
static_assert(offsetof(AServerStatReplicator, NetNumClients) == 0x0002E8, "Member 'AServerStatReplicator::NetNumClients' has a wrong offset!");
static_assert(offsetof(AServerStatReplicator, InPackets) == 0x0002EC, "Member 'AServerStatReplicator::InPackets' has a wrong offset!");
static_assert(offsetof(AServerStatReplicator, OutPackets) == 0x0002F0, "Member 'AServerStatReplicator::OutPackets' has a wrong offset!");
static_assert(offsetof(AServerStatReplicator, InBunches) == 0x0002F4, "Member 'AServerStatReplicator::InBunches' has a wrong offset!");
static_assert(offsetof(AServerStatReplicator, OutBunches) == 0x0002F8, "Member 'AServerStatReplicator::OutBunches' has a wrong offset!");
static_assert(offsetof(AServerStatReplicator, OutLoss) == 0x0002FC, "Member 'AServerStatReplicator::OutLoss' has a wrong offset!");
static_assert(offsetof(AServerStatReplicator, InLoss) == 0x000300, "Member 'AServerStatReplicator::InLoss' has a wrong offset!");
static_assert(offsetof(AServerStatReplicator, VoiceBytesSent) == 0x000304, "Member 'AServerStatReplicator::VoiceBytesSent' has a wrong offset!");
static_assert(offsetof(AServerStatReplicator, VoiceBytesRecv) == 0x000308, "Member 'AServerStatReplicator::VoiceBytesRecv' has a wrong offset!");
static_assert(offsetof(AServerStatReplicator, VoicePacketsSent) == 0x00030C, "Member 'AServerStatReplicator::VoicePacketsSent' has a wrong offset!");
static_assert(offsetof(AServerStatReplicator, VoicePacketsRecv) == 0x000310, "Member 'AServerStatReplicator::VoicePacketsRecv' has a wrong offset!");
static_assert(offsetof(AServerStatReplicator, PercentInVoice) == 0x000314, "Member 'AServerStatReplicator::PercentInVoice' has a wrong offset!");
static_assert(offsetof(AServerStatReplicator, PercentOutVoice) == 0x000318, "Member 'AServerStatReplicator::PercentOutVoice' has a wrong offset!");
static_assert(offsetof(AServerStatReplicator, NumActorChannels) == 0x00031C, "Member 'AServerStatReplicator::NumActorChannels' has a wrong offset!");
static_assert(offsetof(AServerStatReplicator, NumConsideredActors) == 0x000320, "Member 'AServerStatReplicator::NumConsideredActors' has a wrong offset!");
static_assert(offsetof(AServerStatReplicator, PrioritizedActors) == 0x000324, "Member 'AServerStatReplicator::PrioritizedActors' has a wrong offset!");
static_assert(offsetof(AServerStatReplicator, NumRelevantActors) == 0x000328, "Member 'AServerStatReplicator::NumRelevantActors' has a wrong offset!");
static_assert(offsetof(AServerStatReplicator, NumRelevantDeletedActors) == 0x00032C, "Member 'AServerStatReplicator::NumRelevantDeletedActors' has a wrong offset!");
static_assert(offsetof(AServerStatReplicator, NumReplicatedActorAttempts) == 0x000330, "Member 'AServerStatReplicator::NumReplicatedActorAttempts' has a wrong offset!");
static_assert(offsetof(AServerStatReplicator, NumReplicatedActors) == 0x000334, "Member 'AServerStatReplicator::NumReplicatedActors' has a wrong offset!");
static_assert(offsetof(AServerStatReplicator, NumActors) == 0x000338, "Member 'AServerStatReplicator::NumActors' has a wrong offset!");
static_assert(offsetof(AServerStatReplicator, NumNetActors) == 0x00033C, "Member 'AServerStatReplicator::NumNetActors' has a wrong offset!");
static_assert(offsetof(AServerStatReplicator, NumDormantActors) == 0x000340, "Member 'AServerStatReplicator::NumDormantActors' has a wrong offset!");
static_assert(offsetof(AServerStatReplicator, NumInitiallyDormantActors) == 0x000344, "Member 'AServerStatReplicator::NumInitiallyDormantActors' has a wrong offset!");
static_assert(offsetof(AServerStatReplicator, NumNetGUIDsAckd) == 0x000348, "Member 'AServerStatReplicator::NumNetGUIDsAckd' has a wrong offset!");
static_assert(offsetof(AServerStatReplicator, NumNetGUIDsPending) == 0x00034C, "Member 'AServerStatReplicator::NumNetGUIDsPending' has a wrong offset!");
static_assert(offsetof(AServerStatReplicator, NumNetGUIDsUnAckd) == 0x000350, "Member 'AServerStatReplicator::NumNetGUIDsUnAckd' has a wrong offset!");
static_assert(offsetof(AServerStatReplicator, ObjPathBytes) == 0x000354, "Member 'AServerStatReplicator::ObjPathBytes' has a wrong offset!");
static_assert(offsetof(AServerStatReplicator, NetGUIDOutRate) == 0x000358, "Member 'AServerStatReplicator::NetGUIDOutRate' has a wrong offset!");
static_assert(offsetof(AServerStatReplicator, NetGUIDInRate) == 0x00035C, "Member 'AServerStatReplicator::NetGUIDInRate' has a wrong offset!");
static_assert(offsetof(AServerStatReplicator, NetSaturated) == 0x000360, "Member 'AServerStatReplicator::NetSaturated' has a wrong offset!");

// Class Engine.BlueprintGeneratedClass
// 0x0168 (0x0368 - 0x0200)
class UBlueprintGeneratedClass : public UClass
{
public:
	uint8                                         Pad_200[0x8];                                      // 0x0200(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	int32                                         NumReplicatedProperties;                           // 0x0208(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, AssetRegistrySearchable, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bHasNativizedParent : 1;                           // 0x020C(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Deprecated, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bHasCookedComponentInstancingData : 1;             // 0x020C(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_20D[0x3];                                      // 0x020D(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<class UDynamicBlueprintBinding*>       DynamicBindingObjects;                             // 0x0210(0x0010)(ZeroConstructor, UObjectWrapper, NativeAccessSpecifierPublic)
	TArray<class UActorComponent*>                ComponentTemplates;                                // 0x0220(0x0010)(ExportObject, ZeroConstructor, ContainsInstancedReference, UObjectWrapper, NativeAccessSpecifierPublic)
	TArray<class UTimelineTemplate*>              Timelines;                                         // 0x0230(0x0010)(ZeroConstructor, UObjectWrapper, NativeAccessSpecifierPublic)
	TArray<struct FBPComponentClassOverride>      ComponentClassOverrides;                           // 0x0240(0x0010)(ZeroConstructor, NativeAccessSpecifierPublic)
	TArray<struct FFieldNotificationId>           FieldNotifies;                                     // 0x0250(0x0010)(ZeroConstructor, NativeAccessSpecifierPublic)
	uint8                                         Pad_260[0x8];                                      // 0x0260(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	class USimpleConstructionScript*              SimpleConstructionScript;                          // 0x0268(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UInheritableComponentHandler*           InheritableComponentHandler;                       // 0x0270(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UStructProperty*                        UberGraphFramePointerProperty;                     // 0x0278(0x0008)(ZeroConstructor, Deprecated, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_280[0x8];                                      // 0x0280(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	class UFunction*                              UberGraphFunction;                                 // 0x0288(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TMap<class FName, struct FGuid>               CookedPropertyGuids;                               // 0x0290(0x0050)(NativeAccessSpecifierPublic)
	TMap<class FName, struct FBlueprintCookedComponentInstancingData> CookedComponentInstancingData; // 0x02E0(0x0050)(NativeAccessSpecifierPublic)
	uint8                                         Pad_330[0x38];                                     // 0x0330(0x0038)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"BlueprintGeneratedClass">();
	}
	static class UBlueprintGeneratedClass* GetDefaultObj()
	{
		return GetDefaultObjImpl<UBlueprintGeneratedClass>();
	}
};
static_assert(alignof(UBlueprintGeneratedClass) == 0x000008, "Wrong alignment on UBlueprintGeneratedClass");
static_assert(sizeof(UBlueprintGeneratedClass) == 0x000368, "Wrong size on UBlueprintGeneratedClass");
static_assert(offsetof(UBlueprintGeneratedClass, NumReplicatedProperties) == 0x000208, "Member 'UBlueprintGeneratedClass::NumReplicatedProperties' has a wrong offset!");
static_assert(offsetof(UBlueprintGeneratedClass, DynamicBindingObjects) == 0x000210, "Member 'UBlueprintGeneratedClass::DynamicBindingObjects' has a wrong offset!");
static_assert(offsetof(UBlueprintGeneratedClass, ComponentTemplates) == 0x000220, "Member 'UBlueprintGeneratedClass::ComponentTemplates' has a wrong offset!");
static_assert(offsetof(UBlueprintGeneratedClass, Timelines) == 0x000230, "Member 'UBlueprintGeneratedClass::Timelines' has a wrong offset!");
static_assert(offsetof(UBlueprintGeneratedClass, ComponentClassOverrides) == 0x000240, "Member 'UBlueprintGeneratedClass::ComponentClassOverrides' has a wrong offset!");
static_assert(offsetof(UBlueprintGeneratedClass, FieldNotifies) == 0x000250, "Member 'UBlueprintGeneratedClass::FieldNotifies' has a wrong offset!");
static_assert(offsetof(UBlueprintGeneratedClass, SimpleConstructionScript) == 0x000268, "Member 'UBlueprintGeneratedClass::SimpleConstructionScript' has a wrong offset!");
static_assert(offsetof(UBlueprintGeneratedClass, InheritableComponentHandler) == 0x000270, "Member 'UBlueprintGeneratedClass::InheritableComponentHandler' has a wrong offset!");
static_assert(offsetof(UBlueprintGeneratedClass, UberGraphFramePointerProperty) == 0x000278, "Member 'UBlueprintGeneratedClass::UberGraphFramePointerProperty' has a wrong offset!");
static_assert(offsetof(UBlueprintGeneratedClass, UberGraphFunction) == 0x000288, "Member 'UBlueprintGeneratedClass::UberGraphFunction' has a wrong offset!");
static_assert(offsetof(UBlueprintGeneratedClass, CookedPropertyGuids) == 0x000290, "Member 'UBlueprintGeneratedClass::CookedPropertyGuids' has a wrong offset!");
static_assert(offsetof(UBlueprintGeneratedClass, CookedComponentInstancingData) == 0x0002E0, "Member 'UBlueprintGeneratedClass::CookedComponentInstancingData' has a wrong offset!");

// Class Engine.SoundNodeSwitch
// 0x0008 (0x0050 - 0x0048)
class USoundNodeSwitch final : public USoundNode
{
public:
	class FName                                   IntParameterName;                                  // 0x0048(0x0008)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"SoundNodeSwitch">();
	}
	static class USoundNodeSwitch* GetDefaultObj()
	{
		return GetDefaultObjImpl<USoundNodeSwitch>();
	}
};
static_assert(alignof(USoundNodeSwitch) == 0x000008, "Wrong alignment on USoundNodeSwitch");
static_assert(sizeof(USoundNodeSwitch) == 0x000050, "Wrong size on USoundNodeSwitch");
static_assert(offsetof(USoundNodeSwitch, IntParameterName) == 0x000048, "Member 'USoundNodeSwitch::IntParameterName' has a wrong offset!");

// Class Engine.MaterialExpressionFontSample
// 0x0010 (0x00C0 - 0x00B0)
class UMaterialExpressionFontSample : public UMaterialExpression
{
public:
	class UFont*                                  Font;                                              // 0x00B0(0x0008)(Edit, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         FontTexturePage;                                   // 0x00B8(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_BC[0x4];                                       // 0x00BC(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionFontSample">();
	}
	static class UMaterialExpressionFontSample* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionFontSample>();
	}
};
static_assert(alignof(UMaterialExpressionFontSample) == 0x000008, "Wrong alignment on UMaterialExpressionFontSample");
static_assert(sizeof(UMaterialExpressionFontSample) == 0x0000C0, "Wrong size on UMaterialExpressionFontSample");
static_assert(offsetof(UMaterialExpressionFontSample, Font) == 0x0000B0, "Member 'UMaterialExpressionFontSample::Font' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionFontSample, FontTexturePage) == 0x0000B8, "Member 'UMaterialExpressionFontSample::FontTexturePage' has a wrong offset!");

// Class Engine.ForceFeedbackEffect
// 0x0078 (0x00A0 - 0x0028)
class UForceFeedbackEffect final : public UObject
{
public:
	TArray<struct FForceFeedbackChannelDetails>   ChannelDetails;                                    // 0x0028(0x0010)(Edit, ZeroConstructor, NativeAccessSpecifierPublic)
	TMap<class FName, struct FForceFeedbackEffectOverridenChannelDetails> PerDeviceOverrides;        // 0x0038(0x0050)(Edit, NativeAccessSpecifierPublic)
	TArray<class UInputDeviceProperty*>           DeviceProperties;                                  // 0x0088(0x0010)(Edit, ExportObject, ZeroConstructor, ContainsInstancedReference, UObjectWrapper, NativeAccessSpecifierPublic)
	float                                         Duration;                                          // 0x0098(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, EditConst, IsPlainOldData, NoDestructor, AssetRegistrySearchable, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9C[0x4];                                       // 0x009C(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ForceFeedbackEffect">();
	}
	static class UForceFeedbackEffect* GetDefaultObj()
	{
		return GetDefaultObjImpl<UForceFeedbackEffect>();
	}
};
static_assert(alignof(UForceFeedbackEffect) == 0x000008, "Wrong alignment on UForceFeedbackEffect");
static_assert(sizeof(UForceFeedbackEffect) == 0x0000A0, "Wrong size on UForceFeedbackEffect");
static_assert(offsetof(UForceFeedbackEffect, ChannelDetails) == 0x000028, "Member 'UForceFeedbackEffect::ChannelDetails' has a wrong offset!");
static_assert(offsetof(UForceFeedbackEffect, PerDeviceOverrides) == 0x000038, "Member 'UForceFeedbackEffect::PerDeviceOverrides' has a wrong offset!");
static_assert(offsetof(UForceFeedbackEffect, DeviceProperties) == 0x000088, "Member 'UForceFeedbackEffect::DeviceProperties' has a wrong offset!");
static_assert(offsetof(UForceFeedbackEffect, Duration) == 0x000098, "Member 'UForceFeedbackEffect::Duration' has a wrong offset!");

// Class Engine.CameraActor
// 0x0710 (0x09B0 - 0x02A0)
class ACameraActor : public AActor
{
public:
	EAutoReceiveInput                             AutoActivateForPlayer;                             // 0x02A0(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_2A1[0x7];                                      // 0x02A1(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	class UCameraComponent*                       CameraComponent;                                   // 0x02A8(0x0008)(Edit, BlueprintVisible, ExportObject, BlueprintReadOnly, ZeroConstructor, EditConst, InstancedReference, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	class USceneComponent*                        SceneComponent;                                    // 0x02B0(0x0008)(Edit, BlueprintVisible, ExportObject, BlueprintReadOnly, ZeroConstructor, EditConst, InstancedReference, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         bConstrainAspectRatio : 1;                         // 0x02B8(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Deprecated, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate))
	uint8                                         Pad_2B9[0x3];                                      // 0x02B9(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         AspectRatio;                                       // 0x02BC(0x0004)(ZeroConstructor, Deprecated, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	float                                         FOVAngle;                                          // 0x02C0(0x0004)(ZeroConstructor, Deprecated, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	float                                         PostProcessBlendWeight;                            // 0x02C4(0x0004)(ZeroConstructor, Deprecated, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_2C8[0x8];                                      // 0x02C8(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	struct FPostProcessSettings                   PostProcessSettings;                               // 0x02D0(0x06E0)(Deprecated, NativeAccessSpecifierPrivate)

public:
	int32 GetAutoActivatePlayerIndex() const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"CameraActor">();
	}
	static class ACameraActor* GetDefaultObj()
	{
		return GetDefaultObjImpl<ACameraActor>();
	}
};
static_assert(alignof(ACameraActor) == 0x000010, "Wrong alignment on ACameraActor");
static_assert(sizeof(ACameraActor) == 0x0009B0, "Wrong size on ACameraActor");
static_assert(offsetof(ACameraActor, AutoActivateForPlayer) == 0x0002A0, "Member 'ACameraActor::AutoActivateForPlayer' has a wrong offset!");
static_assert(offsetof(ACameraActor, CameraComponent) == 0x0002A8, "Member 'ACameraActor::CameraComponent' has a wrong offset!");
static_assert(offsetof(ACameraActor, SceneComponent) == 0x0002B0, "Member 'ACameraActor::SceneComponent' has a wrong offset!");
static_assert(offsetof(ACameraActor, AspectRatio) == 0x0002BC, "Member 'ACameraActor::AspectRatio' has a wrong offset!");
static_assert(offsetof(ACameraActor, FOVAngle) == 0x0002C0, "Member 'ACameraActor::FOVAngle' has a wrong offset!");
static_assert(offsetof(ACameraActor, PostProcessBlendWeight) == 0x0002C4, "Member 'ACameraActor::PostProcessBlendWeight' has a wrong offset!");
static_assert(offsetof(ACameraActor, PostProcessSettings) == 0x0002D0, "Member 'ACameraActor::PostProcessSettings' has a wrong offset!");

// Class Engine.AudioEngineSubsystem
// 0x0000 (0x0030 - 0x0030)
class UAudioEngineSubsystem : public UDynamicSubsystem
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AudioEngineSubsystem">();
	}
	static class UAudioEngineSubsystem* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAudioEngineSubsystem>();
	}
};
static_assert(alignof(UAudioEngineSubsystem) == 0x000008, "Wrong alignment on UAudioEngineSubsystem");
static_assert(sizeof(UAudioEngineSubsystem) == 0x000030, "Wrong size on UAudioEngineSubsystem");

// Class Engine.MaterialExpressionTruncateLWC
// 0x0028 (0x00D8 - 0x00B0)
class UMaterialExpressionTruncateLWC final : public UMaterialExpression
{
public:
	struct FExpressionInput                       Input;                                             // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionTruncateLWC">();
	}
	static class UMaterialExpressionTruncateLWC* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionTruncateLWC>();
	}
};
static_assert(alignof(UMaterialExpressionTruncateLWC) == 0x000008, "Wrong alignment on UMaterialExpressionTruncateLWC");
static_assert(sizeof(UMaterialExpressionTruncateLWC) == 0x0000D8, "Wrong size on UMaterialExpressionTruncateLWC");
static_assert(offsetof(UMaterialExpressionTruncateLWC, Input) == 0x0000B0, "Member 'UMaterialExpressionTruncateLWC::Input' has a wrong offset!");

// Class Engine.PawnNoiseEmitterComponent
// 0x0038 (0x00E0 - 0x00A8)
class UPawnNoiseEmitterComponent final : public UActorComponent
{
public:
	uint8                                         bAIPerceptionSystemCompatibilityMode : 1;          // 0x00A8(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, DisableEditOnInstance, NoDestructor, AdvancedDisplay, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
	uint8                                         Pad_A9[0x7];                                       // 0x00A9(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	struct FVector                                LastRemoteNoisePosition;                           // 0x00B0(0x0018)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         NoiseLifetime;                                     // 0x00C8(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         LastRemoteNoiseVolume;                             // 0x00CC(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	float                                         LastRemoteNoiseTime;                               // 0x00D0(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	float                                         LastLocalNoiseVolume;                              // 0x00D4(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	float                                         LastLocalNoiseTime;                                // 0x00D8(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_DC[0x4];                                       // 0x00DC(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void MakeNoise(class AActor* NoiseMaker, float Loudness, const struct FVector& NoiseLocation);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"PawnNoiseEmitterComponent">();
	}
	static class UPawnNoiseEmitterComponent* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPawnNoiseEmitterComponent>();
	}
};
static_assert(alignof(UPawnNoiseEmitterComponent) == 0x000008, "Wrong alignment on UPawnNoiseEmitterComponent");
static_assert(sizeof(UPawnNoiseEmitterComponent) == 0x0000E0, "Wrong size on UPawnNoiseEmitterComponent");
static_assert(offsetof(UPawnNoiseEmitterComponent, LastRemoteNoisePosition) == 0x0000B0, "Member 'UPawnNoiseEmitterComponent::LastRemoteNoisePosition' has a wrong offset!");
static_assert(offsetof(UPawnNoiseEmitterComponent, NoiseLifetime) == 0x0000C8, "Member 'UPawnNoiseEmitterComponent::NoiseLifetime' has a wrong offset!");
static_assert(offsetof(UPawnNoiseEmitterComponent, LastRemoteNoiseVolume) == 0x0000CC, "Member 'UPawnNoiseEmitterComponent::LastRemoteNoiseVolume' has a wrong offset!");
static_assert(offsetof(UPawnNoiseEmitterComponent, LastRemoteNoiseTime) == 0x0000D0, "Member 'UPawnNoiseEmitterComponent::LastRemoteNoiseTime' has a wrong offset!");
static_assert(offsetof(UPawnNoiseEmitterComponent, LastLocalNoiseVolume) == 0x0000D4, "Member 'UPawnNoiseEmitterComponent::LastLocalNoiseVolume' has a wrong offset!");
static_assert(offsetof(UPawnNoiseEmitterComponent, LastLocalNoiseTime) == 0x0000D8, "Member 'UPawnNoiseEmitterComponent::LastLocalNoiseTime' has a wrong offset!");

// Class Engine.SoundEffectSubmixPreset
// 0x0000 (0x0068 - 0x0068)
class USoundEffectSubmixPreset : public USoundEffectPreset
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"SoundEffectSubmixPreset">();
	}
	static class USoundEffectSubmixPreset* GetDefaultObj()
	{
		return GetDefaultObjImpl<USoundEffectSubmixPreset>();
	}
};
static_assert(alignof(USoundEffectSubmixPreset) == 0x000008, "Wrong alignment on USoundEffectSubmixPreset");
static_assert(sizeof(USoundEffectSubmixPreset) == 0x000068, "Wrong size on USoundEffectSubmixPreset");

// Class Engine.MaterialExpressionPreSkinnedLocalBounds
// 0x0000 (0x00B0 - 0x00B0)
class UMaterialExpressionPreSkinnedLocalBounds final : public UMaterialExpression
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionPreSkinnedLocalBounds">();
	}
	static class UMaterialExpressionPreSkinnedLocalBounds* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionPreSkinnedLocalBounds>();
	}
};
static_assert(alignof(UMaterialExpressionPreSkinnedLocalBounds) == 0x000008, "Wrong alignment on UMaterialExpressionPreSkinnedLocalBounds");
static_assert(sizeof(UMaterialExpressionPreSkinnedLocalBounds) == 0x0000B0, "Wrong size on UMaterialExpressionPreSkinnedLocalBounds");

// Class Engine.KismetInputLibrary
// 0x0000 (0x0028 - 0x0028)
class UKismetInputLibrary final : public UBlueprintFunctionLibrary
{
public:
	static void CalibrateTilt();
	static bool EqualEqual_InputChordInputChord(const struct FInputChord& A, const struct FInputChord& B);
	static bool EqualEqual_KeyKey(const struct FKey& A, const struct FKey& B);
	static float GetAnalogValue(const struct FAnalogInputEvent& Input);
	static struct FKey GetKey(const struct FKeyEvent& Input);
	static struct FSlateModifierKeysState GetModifierKeysState();
	static int32 GetUserIndex(const struct FKeyEvent& Input);
	static class FText InputChord_GetDisplayName(const struct FInputChord& Key);
	static bool InputEvent_IsAltDown(const struct FInputEvent& Input);
	static bool InputEvent_IsCommandDown(const struct FInputEvent& Input);
	static bool InputEvent_IsControlDown(const struct FInputEvent& Input);
	static bool InputEvent_IsLeftAltDown(const struct FInputEvent& Input);
	static bool InputEvent_IsLeftCommandDown(const struct FInputEvent& Input);
	static bool InputEvent_IsLeftControlDown(const struct FInputEvent& Input);
	static bool InputEvent_IsLeftShiftDown(const struct FInputEvent& Input);
	static bool InputEvent_IsRepeat(const struct FInputEvent& Input);
	static bool InputEvent_IsRightAltDown(const struct FInputEvent& Input);
	static bool InputEvent_IsRightCommandDown(const struct FInputEvent& Input);
	static bool InputEvent_IsRightControlDown(const struct FInputEvent& Input);
	static bool InputEvent_IsRightShiftDown(const struct FInputEvent& Input);
	static bool InputEvent_IsShiftDown(const struct FInputEvent& Input);
	static class FText Key_GetDisplayName(const struct FKey& Key, bool bLongDisplayName);
	static EUINavigationAction Key_GetNavigationAction(const struct FKey& InKey);
	static EUINavigationAction Key_GetNavigationActionFromKey(const struct FKeyEvent& InKeyEvent);
	static EUINavigation Key_GetNavigationDirectionFromAnalog(const struct FAnalogInputEvent& InAnalogEvent);
	static EUINavigation Key_GetNavigationDirectionFromKey(const struct FKeyEvent& InKeyEvent);
	static bool Key_IsAnalog(const struct FKey& Key);
	static bool Key_IsAxis1D(const struct FKey& Key);
	static bool Key_IsAxis2D(const struct FKey& Key);
	static bool Key_IsAxis3D(const struct FKey& Key);
	static bool Key_IsButtonAxis(const struct FKey& Key);
	static bool Key_IsDigital(const struct FKey& Key);
	static bool Key_IsGamepadKey(const struct FKey& Key);
	static bool Key_IsKeyboardKey(const struct FKey& Key);
	static bool Key_IsModifierKey(const struct FKey& Key);
	static bool Key_IsMouseButton(const struct FKey& Key);
	static bool Key_IsValid(const struct FKey& Key);
	static bool Key_IsVectorAxis(const struct FKey& Key);
	static bool ModifierKeysState_IsAltDown(const struct FSlateModifierKeysState& KeysState);
	static bool ModifierKeysState_IsCommandDown(const struct FSlateModifierKeysState& KeysState);
	static bool ModifierKeysState_IsControlDown(const struct FSlateModifierKeysState& KeysState);
	static bool ModifierKeysState_IsShiftDown(const struct FSlateModifierKeysState& KeysState);
	static struct FVector2D PointerEvent_GetCursorDelta(const struct FPointerEvent& Input);
	static struct FKey PointerEvent_GetEffectingButton(const struct FPointerEvent& Input);
	static struct FVector2D PointerEvent_GetGestureDelta(const struct FPointerEvent& Input);
	static ESlateGesture PointerEvent_GetGestureType(const struct FPointerEvent& Input);
	static struct FVector2D PointerEvent_GetLastScreenSpacePosition(const struct FPointerEvent& Input);
	static int32 PointerEvent_GetPointerIndex(const struct FPointerEvent& Input);
	static struct FVector2D PointerEvent_GetScreenSpacePosition(const struct FPointerEvent& Input);
	static int32 PointerEvent_GetTouchpadIndex(const struct FPointerEvent& Input);
	static int32 PointerEvent_GetUserIndex(const struct FPointerEvent& Input);
	static float PointerEvent_GetWheelDelta(const struct FPointerEvent& Input);
	static bool PointerEvent_IsMouseButtonDown(const struct FPointerEvent& Input, const struct FKey& MouseButton);
	static bool PointerEvent_IsTouchEvent(const struct FPointerEvent& Input);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"KismetInputLibrary">();
	}
	static class UKismetInputLibrary* GetDefaultObj()
	{
		return GetDefaultObjImpl<UKismetInputLibrary>();
	}
};
static_assert(alignof(UKismetInputLibrary) == 0x000008, "Wrong alignment on UKismetInputLibrary");
static_assert(sizeof(UKismetInputLibrary) == 0x000028, "Wrong size on UKismetInputLibrary");

// Class Engine.ActiveSoundUpdateInterface
// 0x0000 (0x0000 - 0x0000)
class IActiveSoundUpdateInterface final
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ActiveSoundUpdateInterface">();
	}
	static class IActiveSoundUpdateInterface* GetDefaultObj()
	{
		return GetDefaultObjImpl<IActiveSoundUpdateInterface>();
	}

	class UObject* AsUObject()
	{
		return reinterpret_cast<UObject*>(this);
	}
	const class UObject* AsUObject() const
	{
		return reinterpret_cast<const UObject*>(this);
	}
};
static_assert(alignof(IActiveSoundUpdateInterface) == 0x000001, "Wrong alignment on IActiveSoundUpdateInterface");
static_assert(sizeof(IActiveSoundUpdateInterface) == 0x000001, "Wrong size on IActiveSoundUpdateInterface");

// Class Engine.PoseWatchElement
// 0x0000 (0x0028 - 0x0028)
class UPoseWatchElement : public UObject
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"PoseWatchElement">();
	}
	static class UPoseWatchElement* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPoseWatchElement>();
	}
};
static_assert(alignof(UPoseWatchElement) == 0x000008, "Wrong alignment on UPoseWatchElement");
static_assert(sizeof(UPoseWatchElement) == 0x000028, "Wrong size on UPoseWatchElement");

// Class Engine.PoseWatchPoseElement
// 0x0000 (0x0028 - 0x0028)
class UPoseWatchPoseElement final : public UPoseWatchElement
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"PoseWatchPoseElement">();
	}
	static class UPoseWatchPoseElement* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPoseWatchPoseElement>();
	}
};
static_assert(alignof(UPoseWatchPoseElement) == 0x000008, "Wrong alignment on UPoseWatchPoseElement");
static_assert(sizeof(UPoseWatchPoseElement) == 0x000028, "Wrong size on UPoseWatchPoseElement");

// Class Engine.NetworkSubsystem
// 0x0050 (0x0080 - 0x0030)
class UNetworkSubsystem final : public UWorldSubsystem
{
public:
	uint8                                         Pad_30[0x50];                                      // 0x0030(0x0050)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"NetworkSubsystem">();
	}
	static class UNetworkSubsystem* GetDefaultObj()
	{
		return GetDefaultObjImpl<UNetworkSubsystem>();
	}
};
static_assert(alignof(UNetworkSubsystem) == 0x000008, "Wrong alignment on UNetworkSubsystem");
static_assert(sizeof(UNetworkSubsystem) == 0x000080, "Wrong size on UNetworkSubsystem");

// Class Engine.MaterialExpressionDeltaTime
// 0x0000 (0x00B0 - 0x00B0)
class UMaterialExpressionDeltaTime final : public UMaterialExpression
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionDeltaTime">();
	}
	static class UMaterialExpressionDeltaTime* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionDeltaTime>();
	}
};
static_assert(alignof(UMaterialExpressionDeltaTime) == 0x000008, "Wrong alignment on UMaterialExpressionDeltaTime");
static_assert(sizeof(UMaterialExpressionDeltaTime) == 0x0000B0, "Wrong size on UMaterialExpressionDeltaTime");

// Class Engine.ObjectElementSelectionInterface
// 0x0008 (0x0030 - 0x0028)
class UObjectElementSelectionInterface final : public UObject
{
public:
	uint8                                         Pad_28[0x8];                                       // 0x0028(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ObjectElementSelectionInterface">();
	}
	static class UObjectElementSelectionInterface* GetDefaultObj()
	{
		return GetDefaultObjImpl<UObjectElementSelectionInterface>();
	}
};
static_assert(alignof(UObjectElementSelectionInterface) == 0x000008, "Wrong alignment on UObjectElementSelectionInterface");
static_assert(sizeof(UObjectElementSelectionInterface) == 0x000030, "Wrong size on UObjectElementSelectionInterface");

// Class Engine.AnimationAssetExtensions
// 0x0000 (0x0028 - 0x0028)
class UAnimationAssetExtensions final : public UBlueprintFunctionLibrary
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AnimationAssetExtensions">();
	}
	static class UAnimationAssetExtensions* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAnimationAssetExtensions>();
	}
};
static_assert(alignof(UAnimationAssetExtensions) == 0x000008, "Wrong alignment on UAnimationAssetExtensions");
static_assert(sizeof(UAnimationAssetExtensions) == 0x000028, "Wrong size on UAnimationAssetExtensions");

// Class Engine.Note
// 0x0000 (0x02A0 - 0x02A0)
class ANote final : public AActor
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"Note">();
	}
	static class ANote* GetDefaultObj()
	{
		return GetDefaultObjImpl<ANote>();
	}
};
static_assert(alignof(ANote) == 0x000008, "Wrong alignment on ANote");
static_assert(sizeof(ANote) == 0x0002A0, "Wrong size on ANote");

// Class Engine.AnimBlueprintClassSubsystem_PropertyAccess
// 0x0000 (0x0028 - 0x0028)
class UAnimBlueprintClassSubsystem_PropertyAccess final : public UObject
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AnimBlueprintClassSubsystem_PropertyAccess">();
	}
	static class UAnimBlueprintClassSubsystem_PropertyAccess* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAnimBlueprintClassSubsystem_PropertyAccess>();
	}
};
static_assert(alignof(UAnimBlueprintClassSubsystem_PropertyAccess) == 0x000008, "Wrong alignment on UAnimBlueprintClassSubsystem_PropertyAccess");
static_assert(sizeof(UAnimBlueprintClassSubsystem_PropertyAccess) == 0x000028, "Wrong size on UAnimBlueprintClassSubsystem_PropertyAccess");

// Class Engine.CancellableAsyncAction
// 0x0000 (0x0030 - 0x0030)
class UCancellableAsyncAction : public UBlueprintAsyncActionBase
{
public:
	void Cancel();

	bool IsActive() const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"CancellableAsyncAction">();
	}
	static class UCancellableAsyncAction* GetDefaultObj()
	{
		return GetDefaultObjImpl<UCancellableAsyncAction>();
	}
};
static_assert(alignof(UCancellableAsyncAction) == 0x000008, "Wrong alignment on UCancellableAsyncAction");
static_assert(sizeof(UCancellableAsyncAction) == 0x000030, "Wrong size on UCancellableAsyncAction");

// Class Engine.Interface_AnimCurveMetaData
// 0x0000 (0x0000 - 0x0000)
class IInterface_AnimCurveMetaData final
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"Interface_AnimCurveMetaData">();
	}
	static class IInterface_AnimCurveMetaData* GetDefaultObj()
	{
		return GetDefaultObjImpl<IInterface_AnimCurveMetaData>();
	}

	class UObject* AsUObject()
	{
		return reinterpret_cast<UObject*>(this);
	}
	const class UObject* AsUObject() const
	{
		return reinterpret_cast<const UObject*>(this);
	}
};
static_assert(alignof(IInterface_AnimCurveMetaData) == 0x000001, "Wrong alignment on IInterface_AnimCurveMetaData");
static_assert(sizeof(IInterface_AnimCurveMetaData) == 0x000001, "Wrong size on IInterface_AnimCurveMetaData");

// Class Engine.MaterialExpressionTime
// 0x0008 (0x00B8 - 0x00B0)
class UMaterialExpressionTime final : public UMaterialExpression
{
public:
	uint8                                         bIgnorePause : 1;                                  // 0x00B0(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bOverride_Period : 1;                              // 0x00B0(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_B1[0x3];                                       // 0x00B1(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         Period;                                            // 0x00B4(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionTime">();
	}
	static class UMaterialExpressionTime* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionTime>();
	}
};
static_assert(alignof(UMaterialExpressionTime) == 0x000008, "Wrong alignment on UMaterialExpressionTime");
static_assert(sizeof(UMaterialExpressionTime) == 0x0000B8, "Wrong size on UMaterialExpressionTime");
static_assert(offsetof(UMaterialExpressionTime, Period) == 0x0000B4, "Member 'UMaterialExpressionTime::Period' has a wrong offset!");

// Class Engine.AnimCurveMetaData
// 0x0078 (0x00A0 - 0x0028)
class UAnimCurveMetaData final : public UAssetUserData
{
public:
	uint8                                         Pad_28[0x8];                                       // 0x0028(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	TMap<class FName, struct FCurveMetaData>      CurveMetaData;                                     // 0x0030(0x0050)(NativeAccessSpecifierPrivate)
	uint8                                         Pad_80[0x20];                                      // 0x0080(0x0020)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AnimCurveMetaData">();
	}
	static class UAnimCurveMetaData* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAnimCurveMetaData>();
	}
};
static_assert(alignof(UAnimCurveMetaData) == 0x000008, "Wrong alignment on UAnimCurveMetaData");
static_assert(sizeof(UAnimCurveMetaData) == 0x0000A0, "Wrong size on UAnimCurveMetaData");
static_assert(offsetof(UAnimCurveMetaData, CurveMetaData) == 0x000030, "Member 'UAnimCurveMetaData::CurveMetaData' has a wrong offset!");

// Class Engine.Engine
// 0x1080 (0x10A8 - 0x0028)
class UEngine : public UObject
{
public:
	uint8                                         Pad_28[0x8];                                       // 0x0028(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	class UFont*                                  TinyFont;                                          // 0x0030(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	struct FSoftObjectPath                        TinyFontName;                                      // 0x0038(0x0020)(Edit, ZeroConstructor, Config, GlobalConfig, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UFont*                                  SmallFont;                                         // 0x0058(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	struct FSoftObjectPath                        SmallFontName;                                     // 0x0060(0x0020)(Edit, ZeroConstructor, Config, GlobalConfig, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UFont*                                  MediumFont;                                        // 0x0080(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	struct FSoftObjectPath                        MediumFontName;                                    // 0x0088(0x0020)(Edit, ZeroConstructor, Config, GlobalConfig, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UFont*                                  LargeFont;                                         // 0x00A8(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	struct FSoftObjectPath                        LargeFontName;                                     // 0x00B0(0x0020)(Edit, ZeroConstructor, Config, GlobalConfig, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UFont*                                  SubtitleFont;                                      // 0x00D0(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	struct FSoftObjectPath                        SubtitleFontName;                                  // 0x00D8(0x0020)(Edit, ZeroConstructor, Config, GlobalConfig, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TArray<class UFont*>                          AdditionalFonts;                                   // 0x00F8(0x0010)(ZeroConstructor, UObjectWrapper, NativeAccessSpecifierPrivate)
	TArray<class FString>                         AdditionalFontNames;                               // 0x0108(0x0010)(Edit, ZeroConstructor, Config, GlobalConfig, AdvancedDisplay, NativeAccessSpecifierPublic)
	TSubclassOf<class UConsole>                   ConsoleClass;                                      // 0x0118(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FSoftClassPath                         ConsoleClassName;                                  // 0x0120(0x0020)(Edit, ZeroConstructor, Config, GlobalConfig, NoClear, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TSubclassOf<class UGameViewportClient>        GameViewportClientClass;                           // 0x0140(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FSoftClassPath                         GameViewportClientClassName;                       // 0x0148(0x0020)(Edit, ZeroConstructor, Config, GlobalConfig, NoClear, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TSubclassOf<class ULocalPlayer>               LocalPlayerClass;                                  // 0x0168(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FSoftClassPath                         LocalPlayerClassName;                              // 0x0170(0x0020)(Edit, ZeroConstructor, Config, GlobalConfig, NoClear, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TSubclassOf<class AWorldSettings>             WorldSettingsClass;                                // 0x0190(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FSoftClassPath                         WorldSettingsClassName;                            // 0x0198(0x0020)(Edit, ZeroConstructor, Config, GlobalConfig, NoClear, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FSoftClassPath                         NavigationSystemClassName;                         // 0x01B8(0x0020)(ZeroConstructor, Config, GlobalConfig, NoClear, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TSubclassOf<class UNavigationSystemBase>      NavigationSystemClass;                             // 0x01D8(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FSoftClassPath                         NavigationSystemConfigClassName;                   // 0x01E0(0x0020)(ZeroConstructor, Config, GlobalConfig, NoClear, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TSubclassOf<class UNavigationSystemConfig>    NavigationSystemConfigClass;                       // 0x0200(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FSoftClassPath                         AvoidanceManagerClassName;                         // 0x0208(0x0020)(ZeroConstructor, Config, GlobalConfig, NoClear, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TSubclassOf<class UAvoidanceManager>          AvoidanceManagerClass;                             // 0x0228(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FSoftClassPath                         AIControllerClassName;                             // 0x0230(0x0020)(ZeroConstructor, Config, GlobalConfig, NoClear, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TSubclassOf<class UPhysicsCollisionHandler>   PhysicsCollisionHandlerClass;                      // 0x0250(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FSoftClassPath                         PhysicsCollisionHandlerClassName;                  // 0x0258(0x0020)(Edit, ZeroConstructor, Config, GlobalConfig, NoClear, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FSoftClassPath                         GameUserSettingsClassName;                         // 0x0278(0x0020)(Edit, ZeroConstructor, Config, GlobalConfig, NoClear, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TSubclassOf<class UGameUserSettings>          GameUserSettingsClass;                             // 0x0298(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UGameUserSettings*                      GameUserSettings;                                  // 0x02A0(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TSubclassOf<class ALevelScriptActor>          LevelScriptActorClass;                             // 0x02A8(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FSoftClassPath                         LevelScriptActorClassName;                         // 0x02B0(0x0020)(Edit, ZeroConstructor, Config, GlobalConfig, NoClear, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FSoftClassPath                         DefaultBlueprintBaseClassName;                     // 0x02D0(0x0020)(Edit, ZeroConstructor, Config, GlobalConfig, NoClear, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FSoftClassPath                         GameSingletonClassName;                            // 0x02F0(0x0020)(Edit, ZeroConstructor, Config, GlobalConfig, NoClear, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UObject*                                GameSingleton;                                     // 0x0310(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FSoftClassPath                         AssetManagerClassName;                             // 0x0318(0x0020)(Edit, ZeroConstructor, Config, GlobalConfig, NoClear, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UAssetManager*                          AssetManager;                                      // 0x0338(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UTexture2D*                             DefaultTexture;                                    // 0x0340(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FSoftObjectPath                        DefaultTextureName;                                // 0x0348(0x0020)(ZeroConstructor, Config, GlobalConfig, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UTexture*                               DefaultDiffuseTexture;                             // 0x0368(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FSoftObjectPath                        DefaultDiffuseTextureName;                         // 0x0370(0x0020)(ZeroConstructor, Config, GlobalConfig, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UTexture2D*                             DefaultBSPVertexTexture;                           // 0x0390(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FSoftObjectPath                        DefaultBSPVertexTextureName;                       // 0x0398(0x0020)(ZeroConstructor, Config, GlobalConfig, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UTexture2D*                             HighFrequencyNoiseTexture;                         // 0x03B8(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FSoftObjectPath                        HighFrequencyNoiseTextureName;                     // 0x03C0(0x0020)(ZeroConstructor, Config, GlobalConfig, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UTexture2D*                             DefaultBokehTexture;                               // 0x03E0(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FSoftObjectPath                        DefaultBokehTextureName;                           // 0x03E8(0x0020)(ZeroConstructor, Config, GlobalConfig, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UTexture2D*                             DefaultBloomKernelTexture;                         // 0x0408(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FSoftObjectPath                        DefaultBloomKernelTextureName;                     // 0x0410(0x0020)(ZeroConstructor, Config, GlobalConfig, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UTexture2D*                             DefaultFilmGrainTexture;                           // 0x0430(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FSoftObjectPath                        DefaultFilmGrainTextureName;                       // 0x0438(0x0020)(ZeroConstructor, Config, GlobalConfig, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UMaterial*                              WireframeMaterial;                                 // 0x0458(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FString                                 WireframeMaterialName;                             // 0x0460(0x0010)(ZeroConstructor, Config, GlobalConfig, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UMaterial*                              LandscapePMDebugMaterial;                          // 0x0470(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FString                                 LandscapePMDebugMaterialName;                      // 0x0478(0x0010)(ZeroConstructor, Config, GlobalConfig, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UMaterial*                              DebugMeshMaterial;                                 // 0x0488(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FSoftObjectPath                        DebugMeshMaterialName;                             // 0x0490(0x0020)(ZeroConstructor, Config, GlobalConfig, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UMaterial*                              NaniteHiddenSectionMaterial;                       // 0x04B0(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FString                                 NaniteHiddenSectionMaterialName;                   // 0x04B8(0x0010)(ZeroConstructor, Config, GlobalConfig, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UMaterial*                              EmissiveMeshMaterial;                              // 0x04C8(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FSoftObjectPath                        EmissiveMeshMaterialName;                          // 0x04D0(0x0020)(ZeroConstructor, Config, GlobalConfig, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UMaterial*                              LevelColorationLitMaterial;                        // 0x04F0(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FString                                 LevelColorationLitMaterialName;                    // 0x04F8(0x0010)(ZeroConstructor, Config, GlobalConfig, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UMaterial*                              LevelColorationUnlitMaterial;                      // 0x0508(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FString                                 LevelColorationUnlitMaterialName;                  // 0x0510(0x0010)(ZeroConstructor, Config, GlobalConfig, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UMaterial*                              LightingTexelDensityMaterial;                      // 0x0520(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FString                                 LightingTexelDensityName;                          // 0x0528(0x0010)(ZeroConstructor, Config, GlobalConfig, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UMaterial*                              ShadedLevelColorationLitMaterial;                  // 0x0538(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FString                                 ShadedLevelColorationLitMaterialName;              // 0x0540(0x0010)(ZeroConstructor, Config, GlobalConfig, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UMaterial*                              ShadedLevelColorationUnlitMaterial;                // 0x0550(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FString                                 ShadedLevelColorationUnlitMaterialName;            // 0x0558(0x0010)(ZeroConstructor, Config, GlobalConfig, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UMaterial*                              ShadedLevelTwoSideMaterial;                        // 0x0568(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FString                                 ShadedLevelTwoSideMaterialName;                    // 0x0570(0x0010)(ZeroConstructor, Config, GlobalConfig, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UMaterial*                              RemoveSurfaceMaterial;                             // 0x0580(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FSoftObjectPath                        RemoveSurfaceMaterialName;                         // 0x0588(0x0020)(ZeroConstructor, Config, GlobalConfig, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UMaterial*                              VertexColorMaterial;                               // 0x05A8(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FString                                 VertexColorMaterialName;                           // 0x05B0(0x0010)(ZeroConstructor, Config, GlobalConfig, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UMaterial*                              VertexColorViewModeMaterial_ColorOnly;             // 0x05C0(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FString                                 VertexColorViewModeMaterialName_ColorOnly;         // 0x05C8(0x0010)(ZeroConstructor, Config, GlobalConfig, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UMaterial*                              VertexColorViewModeMaterial_AlphaAsColor;          // 0x05D8(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FString                                 VertexColorViewModeMaterialName_AlphaAsColor;      // 0x05E0(0x0010)(ZeroConstructor, Config, GlobalConfig, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UMaterial*                              VertexColorViewModeMaterial_RedOnly;               // 0x05F0(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FString                                 VertexColorViewModeMaterialName_RedOnly;           // 0x05F8(0x0010)(ZeroConstructor, Config, GlobalConfig, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UMaterial*                              VertexColorViewModeMaterial_GreenOnly;             // 0x0608(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FString                                 VertexColorViewModeMaterialName_GreenOnly;         // 0x0610(0x0010)(ZeroConstructor, Config, GlobalConfig, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UMaterial*                              VertexColorViewModeMaterial_BlueOnly;              // 0x0620(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FString                                 VertexColorViewModeMaterialName_BlueOnly;          // 0x0628(0x0010)(ZeroConstructor, Config, GlobalConfig, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FSoftObjectPath                        DebugEditorMaterialName;                           // 0x0638(0x0020)(ZeroConstructor, Config, GlobalConfig, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UMaterial*                              ConstraintLimitMaterial;                           // 0x0658(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UMaterialInstanceDynamic*               ConstraintLimitMaterialX;                          // 0x0660(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UMaterialInstanceDynamic*               ConstraintLimitMaterialXAxis;                      // 0x0668(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UMaterialInstanceDynamic*               ConstraintLimitMaterialY;                          // 0x0670(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UMaterialInstanceDynamic*               ConstraintLimitMaterialYAxis;                      // 0x0678(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UMaterialInstanceDynamic*               ConstraintLimitMaterialZ;                          // 0x0680(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UMaterialInstanceDynamic*               ConstraintLimitMaterialZAxis;                      // 0x0688(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UMaterialInstanceDynamic*               ConstraintLimitMaterialPrismatic;                  // 0x0690(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UMaterial*                              InvalidLightmapSettingsMaterial;                   // 0x0698(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FSoftObjectPath                        InvalidLightmapSettingsMaterialName;               // 0x06A0(0x0020)(ZeroConstructor, Config, GlobalConfig, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UMaterial*                              PreviewShadowsIndicatorMaterial;                   // 0x06C0(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FSoftObjectPath                        PreviewShadowsIndicatorMaterialName;               // 0x06C8(0x0020)(Edit, ZeroConstructor, Config, GlobalConfig, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UMaterial*                              ArrowMaterial;                                     // 0x06E8(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UMaterialInstanceDynamic*               ArrowMaterialYellow;                               // 0x06F0(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FSoftObjectPath                        ArrowMaterialName;                                 // 0x06F8(0x0020)(ZeroConstructor, Config, GlobalConfig, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FLinearColor                           LightingOnlyBrightness;                            // 0x0718(0x0010)(ZeroConstructor, Config, GlobalConfig, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TArray<struct FLinearColor>                   ShaderComplexityColors;                            // 0x0728(0x0010)(ZeroConstructor, Config, GlobalConfig, NativeAccessSpecifierPublic)
	TArray<struct FLinearColor>                   QuadComplexityColors;                              // 0x0738(0x0010)(ZeroConstructor, Config, GlobalConfig, NativeAccessSpecifierPublic)
	TArray<struct FLinearColor>                   LightComplexityColors;                             // 0x0748(0x0010)(ZeroConstructor, Config, GlobalConfig, NativeAccessSpecifierPublic)
	TArray<struct FLinearColor>                   StationaryLightOverlapColors;                      // 0x0758(0x0010)(ZeroConstructor, Config, GlobalConfig, NativeAccessSpecifierPublic)
	TArray<struct FLinearColor>                   LODColorationColors;                               // 0x0768(0x0010)(ZeroConstructor, Config, GlobalConfig, NativeAccessSpecifierPublic)
	TArray<struct FLinearColor>                   HLODColorationColors;                              // 0x0778(0x0010)(ZeroConstructor, Config, GlobalConfig, NativeAccessSpecifierPublic)
	TArray<struct FLinearColor>                   StreamingAccuracyColors;                           // 0x0788(0x0010)(ZeroConstructor, Config, GlobalConfig, NativeAccessSpecifierPublic)
	struct FLinearColor                           GPUSkinCacheVisualizationExcludedColor;            // 0x0798(0x0010)(ZeroConstructor, Config, GlobalConfig, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FLinearColor                           GPUSkinCacheVisualizationIncludedColor;            // 0x07A8(0x0010)(ZeroConstructor, Config, GlobalConfig, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FLinearColor                           GPUSkinCacheVisualizationRecomputeTangentsColor;   // 0x07B8(0x0010)(ZeroConstructor, Config, GlobalConfig, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         GPUSkinCacheVisualizationLowMemoryThresholdInMB;   // 0x07C8(0x0004)(ZeroConstructor, Config, GlobalConfig, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         GPUSkinCacheVisualizationHighMemoryThresholdInMB;  // 0x07CC(0x0004)(ZeroConstructor, Config, GlobalConfig, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FLinearColor                           GPUSkinCacheVisualizationLowMemoryColor;           // 0x07D0(0x0010)(ZeroConstructor, Config, GlobalConfig, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FLinearColor                           GPUSkinCacheVisualizationMidMemoryColor;           // 0x07E0(0x0010)(ZeroConstructor, Config, GlobalConfig, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FLinearColor                           GPUSkinCacheVisualizationHighMemoryColor;          // 0x07F0(0x0010)(ZeroConstructor, Config, GlobalConfig, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TArray<struct FLinearColor>                   GPUSkinCacheVisualizationRayTracingLODOffsetColors; // 0x0800(0x0010)(ZeroConstructor, Config, GlobalConfig, NativeAccessSpecifierPublic)
	float                                         MaxPixelShaderAdditiveComplexityCount;             // 0x0810(0x0004)(ZeroConstructor, Config, GlobalConfig, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         MaxES3PixelShaderAdditiveComplexityCount;          // 0x0814(0x0004)(ZeroConstructor, Config, GlobalConfig, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         MinLightMapDensity;                                // 0x0818(0x0004)(ZeroConstructor, Config, GlobalConfig, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         IdealLightMapDensity;                              // 0x081C(0x0004)(ZeroConstructor, Config, GlobalConfig, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         MaxLightMapDensity;                                // 0x0820(0x0004)(ZeroConstructor, Config, GlobalConfig, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bRenderLightMapDensityGrayscale : 1;               // 0x0824(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Config, GlobalConfig, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_825[0x3];                                      // 0x0825(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         RenderLightMapDensityGrayscaleScale;               // 0x0828(0x0004)(ZeroConstructor, Config, GlobalConfig, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         RenderLightMapDensityColorScale;                   // 0x082C(0x0004)(ZeroConstructor, Config, GlobalConfig, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FLinearColor                           LightMapDensityVertexMappedColor;                  // 0x0830(0x0010)(ZeroConstructor, Config, GlobalConfig, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FLinearColor                           LightMapDensitySelectedColor;                      // 0x0840(0x0010)(ZeroConstructor, Config, GlobalConfig, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TArray<struct FStatColorMapping>              StatColorMappings;                                 // 0x0850(0x0010)(ZeroConstructor, Config, GlobalConfig, NativeAccessSpecifierPublic)
	class UPhysicalMaterial*                      DefaultPhysMaterial;                               // 0x0860(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FSoftObjectPath                        DefaultPhysMaterialName;                           // 0x0868(0x0020)(ZeroConstructor, Config, GlobalConfig, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UPhysicalMaterial*                      DefaultDestructiblePhysMaterial;                   // 0x0888(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FSoftObjectPath                        DefaultDestructiblePhysMaterialName;               // 0x0890(0x0020)(Edit, ZeroConstructor, Config, GlobalConfig, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TArray<struct FGameNameRedirect>              ActiveGameNameRedirects;                           // 0x08B0(0x0010)(ZeroConstructor, Config, NativeAccessSpecifierPublic)
	TArray<struct FClassRedirect>                 ActiveClassRedirects;                              // 0x08C0(0x0010)(ZeroConstructor, Config, NativeAccessSpecifierPublic)
	TArray<struct FPluginRedirect>                ActivePluginRedirects;                             // 0x08D0(0x0010)(ZeroConstructor, Config, NativeAccessSpecifierPublic)
	TArray<struct FStructRedirect>                ActiveStructRedirects;                             // 0x08E0(0x0010)(ZeroConstructor, Config, NativeAccessSpecifierPublic)
	class UTexture2D*                             PreIntegratedSkinBRDFTexture;                      // 0x08F0(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FSoftObjectPath                        PreIntegratedSkinBRDFTextureName;                  // 0x08F8(0x0020)(ZeroConstructor, Config, GlobalConfig, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UTexture2D*                             BlueNoiseScalarTexture;                            // 0x0918(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UTexture2D*                             BlueNoiseVec2Texture;                              // 0x0920(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FSoftObjectPath                        BlueNoiseScalarTextureName;                        // 0x0928(0x0020)(ZeroConstructor, Config, GlobalConfig, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FSoftObjectPath                        BlueNoiseVec2TextureName;                          // 0x0948(0x0020)(ZeroConstructor, Config, GlobalConfig, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UTexture2DArray*                        GlintTexture;                                      // 0x0968(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UTexture2DArray*                        GlintTexture2;                                     // 0x0970(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FSoftObjectPath                        GlintTextureName;                                  // 0x0978(0x0020)(ZeroConstructor, Config, GlobalConfig, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FSoftObjectPath                        GlintTexture2Name;                                 // 0x0998(0x0020)(ZeroConstructor, Config, GlobalConfig, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UVolumeTexture*                         SimpleVolumeTexture;                               // 0x09B8(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FSoftObjectPath                        SimpleVolumeTextureName;                           // 0x09C0(0x0020)(ZeroConstructor, Config, GlobalConfig, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UVolumeTexture*                         SimpleVolumeEnvTexture;                            // 0x09E0(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FSoftObjectPath                        SimpleVolumeEnvTextureName;                        // 0x09E8(0x0020)(ZeroConstructor, Config, GlobalConfig, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UTexture2D*                             MiniFontTexture;                                   // 0x0A08(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FSoftObjectPath                        MiniFontTextureName;                               // 0x0A10(0x0020)(ZeroConstructor, Config, GlobalConfig, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UTexture*                               WeightMapPlaceholderTexture;                       // 0x0A30(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FSoftObjectPath                        WeightMapPlaceholderTextureName;                   // 0x0A38(0x0020)(ZeroConstructor, Config, GlobalConfig, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UTexture2D*                             LightMapDensityTexture;                            // 0x0A58(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FSoftObjectPath                        LightMapDensityTextureName;                        // 0x0A60(0x0020)(ZeroConstructor, Config, GlobalConfig, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_A80[0x8];                                      // 0x0A80(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	class UGameViewportClient*                    GameViewport;                                      // 0x0A88(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TArray<class FString>                         DeferredCommands;                                  // 0x0A90(0x0010)(ZeroConstructor, NativeAccessSpecifierPublic)
	float                                         NearClipPlane;                                     // 0x0AA0(0x0004)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bSubtitlesEnabled : 1;                             // 0x0AA4(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bSubtitlesForcedOff : 1;                           // 0x0AA4(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_AA5[0x3];                                      // 0x0AA5(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	int32                                         MaximumLoopIterationCount;                         // 0x0AA8(0x0004)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bCanBlueprintsTickByDefault : 1;                   // 0x0AAC(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bOptimizeAnimBlueprintMemberVariableAccess : 1;    // 0x0AAC(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bAllowMultiThreadedAnimationUpdate : 1;            // 0x0AAC(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Edit, Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bEnableEditorPSysRealtimeLOD : 1;                  // 0x0AAC(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         BitPad_AAC_4 : 1;                                  // 0x0AAC(0x0001)(Fixing Bit-Field Size Between Bits [ Dumper-7 ])
	uint8                                         bSmoothFrameRate : 1;                              // 0x0AAC(0x0001)(BitIndex: 0x05, PropSize: 0x0001 (Edit, Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bUseFixedFrameRate : 1;                            // 0x0AAC(0x0001)(BitIndex: 0x06, PropSize: 0x0001 (Edit, Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_AAD[0x3];                                      // 0x0AAD(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         FixedFrameRate;                                    // 0x0AB0(0x0004)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FFloatRange                            SmoothedFrameRateRange;                            // 0x0AB4(0x0010)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_AC4[0x4];                                      // 0x0AC4(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	class UEngineCustomTimeStep*                  CustomTimeStep;                                    // 0x0AC8(0x0008)(ZeroConstructor, Transient, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_AD0[0x20];                                     // 0x0AD0(0x0020)(Fixing Size After Last Property [ Dumper-7 ])
	struct FSoftClassPath                         CustomTimeStepClassName;                           // 0x0AF0(0x0020)(Edit, ZeroConstructor, Config, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UTimecodeProvider*                      TimecodeProvider;                                  // 0x0B10(0x0008)(ZeroConstructor, Transient, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_B18[0x20];                                     // 0x0B18(0x0020)(Fixing Size After Last Property [ Dumper-7 ])
	struct FSoftClassPath                         TimecodeProviderClassName;                         // 0x0B38(0x0020)(Edit, ZeroConstructor, Config, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bGenerateDefaultTimecode;                          // 0x0B58(0x0001)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_B59[0x3];                                      // 0x0B59(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	struct FFrameRate                             GenerateDefaultTimecodeFrameRate;                  // 0x0B5C(0x0008)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         GenerateDefaultTimecodeFrameDelay;                 // 0x0B64(0x0004)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bCheckForMultiplePawnsSpawnedInAFrame : 1;         // 0x0B68(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_B69[0x3];                                      // 0x0B69(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	int32                                         NumPawnsAllowedToBeSpawnedInAFrame;                // 0x0B6C(0x0004)(ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bShouldGenerateLowQualityLightmaps : 1;            // 0x0B70(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Config, GlobalConfig, Deprecated, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_B71[0x3];                                      // 0x0B71(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	struct FColor                                 C_WorldBox;                                        // 0x0B74(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FColor                                 C_BrushWire;                                       // 0x0B78(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FColor                                 C_AddWire;                                         // 0x0B7C(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FColor                                 C_SubtractWire;                                    // 0x0B80(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FColor                                 C_SemiSolidWire;                                   // 0x0B84(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FColor                                 C_NonSolidWire;                                    // 0x0B88(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FColor                                 C_WireBackground;                                  // 0x0B8C(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FColor                                 C_ScaleBoxHi;                                      // 0x0B90(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FColor                                 C_VolumeCollision;                                 // 0x0B94(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FColor                                 C_BSPCollision;                                    // 0x0B98(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FColor                                 C_OrthoBackground;                                 // 0x0B9C(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FColor                                 C_Volume;                                          // 0x0BA0(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FColor                                 C_BrushShape;                                      // 0x0BA4(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_BA8[0x8];                                      // 0x0BA8(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	struct FDirectoryPath                         GameScreenshotSaveDirectory;                       // 0x0BB0(0x0010)(Edit, ZeroConstructor, Config, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          UseStaticMeshMinLODPerQualityLevels;               // 0x0BC0(0x0001)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          UseSkeletalMeshMinLODPerQualityLevels;             // 0x0BC1(0x0001)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          UseGrassVarityPerQualityLevels;                    // 0x0BC2(0x0001)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	ETransitionType                               TransitionType;                                    // 0x0BC3(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_BC4[0x4];                                      // 0x0BC4(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	class FString                                 TransitionDescription;                             // 0x0BC8(0x0010)(ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FString                                 TransitionGameMode;                                // 0x0BD8(0x0010)(ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bAllowMatureLanguage : 1;                          // 0x0BE8(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_BE9[0x3];                                      // 0x0BE9(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         CameraRotationThreshold;                           // 0x0BEC(0x0004)(ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         CameraTranslationThreshold;                        // 0x0BF0(0x0004)(ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         PrimitiveProbablyVisibleTime;                      // 0x0BF4(0x0004)(ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         MaxOcclusionPixelsFraction;                        // 0x0BF8(0x0004)(ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bPauseOnLossOfFocus : 1;                           // 0x0BFC(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_BFD[0x3];                                      // 0x0BFD(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	int32                                         MaxParticleResize;                                 // 0x0C00(0x0004)(ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         MaxParticleResizeWarn;                             // 0x0C04(0x0004)(ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TArray<struct FDropNoteInfo>                  PendingDroppedNotes;                               // 0x0C08(0x0010)(ZeroConstructor, Transient, NativeAccessSpecifierPublic)
	float                                         NetClientTicksPerSecond;                           // 0x0C18(0x0004)(ZeroConstructor, Config, GlobalConfig, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         DisplayGamma;                                      // 0x0C1C(0x0004)(ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         MinDesiredFrameRate;                               // 0x0C20(0x0004)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FLinearColor                           DefaultSelectedMaterialColor;                      // 0x0C24(0x0010)(ZeroConstructor, Config, GlobalConfig, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	struct FLinearColor                           SelectedMaterialColor;                             // 0x0C34(0x0010)(ZeroConstructor, Transient, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	struct FLinearColor                           SelectionOutlineColor;                             // 0x0C44(0x0010)(ZeroConstructor, Transient, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	struct FLinearColor                           SubduedSelectionOutlineColor;                      // 0x0C54(0x0010)(ZeroConstructor, Transient, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	struct FLinearColor                           SelectedMaterialColorOverride;                     // 0x0C64(0x0010)(ZeroConstructor, Transient, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	bool                                          bIsOverridingSelectedColor;                        // 0x0C74(0x0001)(ZeroConstructor, Transient, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_C75[0x3];                                      // 0x0C75(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	uint8                                         bEnableOnScreenDebugMessages : 1;                  // 0x0C78(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Config, GlobalConfig, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bEnableOnScreenDebugMessagesDisplay : 1;           // 0x0C78(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Transient, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bSuppressMapWarnings : 1;                          // 0x0C78(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Config, GlobalConfig, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bDisableAILogging : 1;                             // 0x0C78(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (Config, GlobalConfig, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_C79[0x3];                                      // 0x0C79(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	uint32                                        bEnableVisualLogRecordingOnStart;                  // 0x0C7C(0x0004)(ZeroConstructor, Config, GlobalConfig, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         ScreenSaverInhibitorSemaphore;                     // 0x0C80(0x0004)(ZeroConstructor, Transient, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         bLockReadOnlyLevels : 1;                           // 0x0C84(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Transient, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_C85[0x3];                                      // 0x0C85(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	class FString                                 ParticleEventManagerClassPath;                     // 0x0C88(0x0010)(ZeroConstructor, Config, GlobalConfig, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         SelectionHighlightIntensity;                       // 0x0C98(0x0004)(ZeroConstructor, Transient, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         BSPSelectionHighlightIntensity;                    // 0x0C9C(0x0004)(ZeroConstructor, Transient, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         SelectionHighlightIntensityBillboards;             // 0x0CA0(0x0004)(ZeroConstructor, Transient, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_CA4[0x294];                                    // 0x0CA4(0x0294)(Fixing Size After Last Property [ Dumper-7 ])
	uint32                                        GlobalNetTravelCount;                              // 0x0F38(0x0004)(ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_F3C[0x4];                                      // 0x0F3C(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<struct FNetDriverDefinition>           NetDriverDefinitions;                              // 0x0F40(0x0010)(ZeroConstructor, Transient, Config, NativeAccessSpecifierPublic)
	TArray<struct FIrisNetDriverConfig>           IrisNetDriverConfigs;                              // 0x0F50(0x0010)(ZeroConstructor, Transient, Config, NativeAccessSpecifierPublic)
	TArray<class FString>                         ServerActors;                                      // 0x0F60(0x0010)(ZeroConstructor, Config, NativeAccessSpecifierPublic)
	TArray<class FString>                         RuntimeServerActors;                               // 0x0F70(0x0010)(ZeroConstructor, NativeAccessSpecifierPublic)
	float                                         NetErrorLogInterval;                               // 0x0F80(0x0004)(ZeroConstructor, Config, GlobalConfig, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bStartedLoadMapMovie : 1;                          // 0x0F84(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Transient, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_F85[0x3B];                                     // 0x0F85(0x003B)(Fixing Size After Last Property [ Dumper-7 ])
	int32                                         NextWorldContextHandle;                            // 0x0FC0(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_FC4[0xE4];                                     // 0x0FC4(0x00E4)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UEngine* GetEngine();

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"Engine">();
	}
	static class UEngine* GetDefaultObj()
	{
		return GetDefaultObjImpl<UEngine>();
	}
};
static_assert(alignof(UEngine) == 0x000008, "Wrong alignment on UEngine");
static_assert(sizeof(UEngine) == 0x0010A8, "Wrong size on UEngine");
static_assert(offsetof(UEngine, TinyFont) == 0x000030, "Member 'UEngine::TinyFont' has a wrong offset!");
static_assert(offsetof(UEngine, TinyFontName) == 0x000038, "Member 'UEngine::TinyFontName' has a wrong offset!");
static_assert(offsetof(UEngine, SmallFont) == 0x000058, "Member 'UEngine::SmallFont' has a wrong offset!");
static_assert(offsetof(UEngine, SmallFontName) == 0x000060, "Member 'UEngine::SmallFontName' has a wrong offset!");
static_assert(offsetof(UEngine, MediumFont) == 0x000080, "Member 'UEngine::MediumFont' has a wrong offset!");
static_assert(offsetof(UEngine, MediumFontName) == 0x000088, "Member 'UEngine::MediumFontName' has a wrong offset!");
static_assert(offsetof(UEngine, LargeFont) == 0x0000A8, "Member 'UEngine::LargeFont' has a wrong offset!");
static_assert(offsetof(UEngine, LargeFontName) == 0x0000B0, "Member 'UEngine::LargeFontName' has a wrong offset!");
static_assert(offsetof(UEngine, SubtitleFont) == 0x0000D0, "Member 'UEngine::SubtitleFont' has a wrong offset!");
static_assert(offsetof(UEngine, SubtitleFontName) == 0x0000D8, "Member 'UEngine::SubtitleFontName' has a wrong offset!");
static_assert(offsetof(UEngine, AdditionalFonts) == 0x0000F8, "Member 'UEngine::AdditionalFonts' has a wrong offset!");
static_assert(offsetof(UEngine, AdditionalFontNames) == 0x000108, "Member 'UEngine::AdditionalFontNames' has a wrong offset!");
static_assert(offsetof(UEngine, ConsoleClass) == 0x000118, "Member 'UEngine::ConsoleClass' has a wrong offset!");
static_assert(offsetof(UEngine, ConsoleClassName) == 0x000120, "Member 'UEngine::ConsoleClassName' has a wrong offset!");
static_assert(offsetof(UEngine, GameViewportClientClass) == 0x000140, "Member 'UEngine::GameViewportClientClass' has a wrong offset!");
static_assert(offsetof(UEngine, GameViewportClientClassName) == 0x000148, "Member 'UEngine::GameViewportClientClassName' has a wrong offset!");
static_assert(offsetof(UEngine, LocalPlayerClass) == 0x000168, "Member 'UEngine::LocalPlayerClass' has a wrong offset!");
static_assert(offsetof(UEngine, LocalPlayerClassName) == 0x000170, "Member 'UEngine::LocalPlayerClassName' has a wrong offset!");
static_assert(offsetof(UEngine, WorldSettingsClass) == 0x000190, "Member 'UEngine::WorldSettingsClass' has a wrong offset!");
static_assert(offsetof(UEngine, WorldSettingsClassName) == 0x000198, "Member 'UEngine::WorldSettingsClassName' has a wrong offset!");
static_assert(offsetof(UEngine, NavigationSystemClassName) == 0x0001B8, "Member 'UEngine::NavigationSystemClassName' has a wrong offset!");
static_assert(offsetof(UEngine, NavigationSystemClass) == 0x0001D8, "Member 'UEngine::NavigationSystemClass' has a wrong offset!");
static_assert(offsetof(UEngine, NavigationSystemConfigClassName) == 0x0001E0, "Member 'UEngine::NavigationSystemConfigClassName' has a wrong offset!");
static_assert(offsetof(UEngine, NavigationSystemConfigClass) == 0x000200, "Member 'UEngine::NavigationSystemConfigClass' has a wrong offset!");
static_assert(offsetof(UEngine, AvoidanceManagerClassName) == 0x000208, "Member 'UEngine::AvoidanceManagerClassName' has a wrong offset!");
static_assert(offsetof(UEngine, AvoidanceManagerClass) == 0x000228, "Member 'UEngine::AvoidanceManagerClass' has a wrong offset!");
static_assert(offsetof(UEngine, AIControllerClassName) == 0x000230, "Member 'UEngine::AIControllerClassName' has a wrong offset!");
static_assert(offsetof(UEngine, PhysicsCollisionHandlerClass) == 0x000250, "Member 'UEngine::PhysicsCollisionHandlerClass' has a wrong offset!");
static_assert(offsetof(UEngine, PhysicsCollisionHandlerClassName) == 0x000258, "Member 'UEngine::PhysicsCollisionHandlerClassName' has a wrong offset!");
static_assert(offsetof(UEngine, GameUserSettingsClassName) == 0x000278, "Member 'UEngine::GameUserSettingsClassName' has a wrong offset!");
static_assert(offsetof(UEngine, GameUserSettingsClass) == 0x000298, "Member 'UEngine::GameUserSettingsClass' has a wrong offset!");
static_assert(offsetof(UEngine, GameUserSettings) == 0x0002A0, "Member 'UEngine::GameUserSettings' has a wrong offset!");
static_assert(offsetof(UEngine, LevelScriptActorClass) == 0x0002A8, "Member 'UEngine::LevelScriptActorClass' has a wrong offset!");
static_assert(offsetof(UEngine, LevelScriptActorClassName) == 0x0002B0, "Member 'UEngine::LevelScriptActorClassName' has a wrong offset!");
static_assert(offsetof(UEngine, DefaultBlueprintBaseClassName) == 0x0002D0, "Member 'UEngine::DefaultBlueprintBaseClassName' has a wrong offset!");
static_assert(offsetof(UEngine, GameSingletonClassName) == 0x0002F0, "Member 'UEngine::GameSingletonClassName' has a wrong offset!");
static_assert(offsetof(UEngine, GameSingleton) == 0x000310, "Member 'UEngine::GameSingleton' has a wrong offset!");
static_assert(offsetof(UEngine, AssetManagerClassName) == 0x000318, "Member 'UEngine::AssetManagerClassName' has a wrong offset!");
static_assert(offsetof(UEngine, AssetManager) == 0x000338, "Member 'UEngine::AssetManager' has a wrong offset!");
static_assert(offsetof(UEngine, DefaultTexture) == 0x000340, "Member 'UEngine::DefaultTexture' has a wrong offset!");
static_assert(offsetof(UEngine, DefaultTextureName) == 0x000348, "Member 'UEngine::DefaultTextureName' has a wrong offset!");
static_assert(offsetof(UEngine, DefaultDiffuseTexture) == 0x000368, "Member 'UEngine::DefaultDiffuseTexture' has a wrong offset!");
static_assert(offsetof(UEngine, DefaultDiffuseTextureName) == 0x000370, "Member 'UEngine::DefaultDiffuseTextureName' has a wrong offset!");
static_assert(offsetof(UEngine, DefaultBSPVertexTexture) == 0x000390, "Member 'UEngine::DefaultBSPVertexTexture' has a wrong offset!");
static_assert(offsetof(UEngine, DefaultBSPVertexTextureName) == 0x000398, "Member 'UEngine::DefaultBSPVertexTextureName' has a wrong offset!");
static_assert(offsetof(UEngine, HighFrequencyNoiseTexture) == 0x0003B8, "Member 'UEngine::HighFrequencyNoiseTexture' has a wrong offset!");
static_assert(offsetof(UEngine, HighFrequencyNoiseTextureName) == 0x0003C0, "Member 'UEngine::HighFrequencyNoiseTextureName' has a wrong offset!");
static_assert(offsetof(UEngine, DefaultBokehTexture) == 0x0003E0, "Member 'UEngine::DefaultBokehTexture' has a wrong offset!");
static_assert(offsetof(UEngine, DefaultBokehTextureName) == 0x0003E8, "Member 'UEngine::DefaultBokehTextureName' has a wrong offset!");
static_assert(offsetof(UEngine, DefaultBloomKernelTexture) == 0x000408, "Member 'UEngine::DefaultBloomKernelTexture' has a wrong offset!");
static_assert(offsetof(UEngine, DefaultBloomKernelTextureName) == 0x000410, "Member 'UEngine::DefaultBloomKernelTextureName' has a wrong offset!");
static_assert(offsetof(UEngine, DefaultFilmGrainTexture) == 0x000430, "Member 'UEngine::DefaultFilmGrainTexture' has a wrong offset!");
static_assert(offsetof(UEngine, DefaultFilmGrainTextureName) == 0x000438, "Member 'UEngine::DefaultFilmGrainTextureName' has a wrong offset!");
static_assert(offsetof(UEngine, WireframeMaterial) == 0x000458, "Member 'UEngine::WireframeMaterial' has a wrong offset!");
static_assert(offsetof(UEngine, WireframeMaterialName) == 0x000460, "Member 'UEngine::WireframeMaterialName' has a wrong offset!");
static_assert(offsetof(UEngine, LandscapePMDebugMaterial) == 0x000470, "Member 'UEngine::LandscapePMDebugMaterial' has a wrong offset!");
static_assert(offsetof(UEngine, LandscapePMDebugMaterialName) == 0x000478, "Member 'UEngine::LandscapePMDebugMaterialName' has a wrong offset!");
static_assert(offsetof(UEngine, DebugMeshMaterial) == 0x000488, "Member 'UEngine::DebugMeshMaterial' has a wrong offset!");
static_assert(offsetof(UEngine, DebugMeshMaterialName) == 0x000490, "Member 'UEngine::DebugMeshMaterialName' has a wrong offset!");
static_assert(offsetof(UEngine, NaniteHiddenSectionMaterial) == 0x0004B0, "Member 'UEngine::NaniteHiddenSectionMaterial' has a wrong offset!");
static_assert(offsetof(UEngine, NaniteHiddenSectionMaterialName) == 0x0004B8, "Member 'UEngine::NaniteHiddenSectionMaterialName' has a wrong offset!");
static_assert(offsetof(UEngine, EmissiveMeshMaterial) == 0x0004C8, "Member 'UEngine::EmissiveMeshMaterial' has a wrong offset!");
static_assert(offsetof(UEngine, EmissiveMeshMaterialName) == 0x0004D0, "Member 'UEngine::EmissiveMeshMaterialName' has a wrong offset!");
static_assert(offsetof(UEngine, LevelColorationLitMaterial) == 0x0004F0, "Member 'UEngine::LevelColorationLitMaterial' has a wrong offset!");
static_assert(offsetof(UEngine, LevelColorationLitMaterialName) == 0x0004F8, "Member 'UEngine::LevelColorationLitMaterialName' has a wrong offset!");
static_assert(offsetof(UEngine, LevelColorationUnlitMaterial) == 0x000508, "Member 'UEngine::LevelColorationUnlitMaterial' has a wrong offset!");
static_assert(offsetof(UEngine, LevelColorationUnlitMaterialName) == 0x000510, "Member 'UEngine::LevelColorationUnlitMaterialName' has a wrong offset!");
static_assert(offsetof(UEngine, LightingTexelDensityMaterial) == 0x000520, "Member 'UEngine::LightingTexelDensityMaterial' has a wrong offset!");
static_assert(offsetof(UEngine, LightingTexelDensityName) == 0x000528, "Member 'UEngine::LightingTexelDensityName' has a wrong offset!");
static_assert(offsetof(UEngine, ShadedLevelColorationLitMaterial) == 0x000538, "Member 'UEngine::ShadedLevelColorationLitMaterial' has a wrong offset!");
static_assert(offsetof(UEngine, ShadedLevelColorationLitMaterialName) == 0x000540, "Member 'UEngine::ShadedLevelColorationLitMaterialName' has a wrong offset!");
static_assert(offsetof(UEngine, ShadedLevelColorationUnlitMaterial) == 0x000550, "Member 'UEngine::ShadedLevelColorationUnlitMaterial' has a wrong offset!");
static_assert(offsetof(UEngine, ShadedLevelColorationUnlitMaterialName) == 0x000558, "Member 'UEngine::ShadedLevelColorationUnlitMaterialName' has a wrong offset!");
static_assert(offsetof(UEngine, ShadedLevelTwoSideMaterial) == 0x000568, "Member 'UEngine::ShadedLevelTwoSideMaterial' has a wrong offset!");
static_assert(offsetof(UEngine, ShadedLevelTwoSideMaterialName) == 0x000570, "Member 'UEngine::ShadedLevelTwoSideMaterialName' has a wrong offset!");
static_assert(offsetof(UEngine, RemoveSurfaceMaterial) == 0x000580, "Member 'UEngine::RemoveSurfaceMaterial' has a wrong offset!");
static_assert(offsetof(UEngine, RemoveSurfaceMaterialName) == 0x000588, "Member 'UEngine::RemoveSurfaceMaterialName' has a wrong offset!");
static_assert(offsetof(UEngine, VertexColorMaterial) == 0x0005A8, "Member 'UEngine::VertexColorMaterial' has a wrong offset!");
static_assert(offsetof(UEngine, VertexColorMaterialName) == 0x0005B0, "Member 'UEngine::VertexColorMaterialName' has a wrong offset!");
static_assert(offsetof(UEngine, VertexColorViewModeMaterial_ColorOnly) == 0x0005C0, "Member 'UEngine::VertexColorViewModeMaterial_ColorOnly' has a wrong offset!");
static_assert(offsetof(UEngine, VertexColorViewModeMaterialName_ColorOnly) == 0x0005C8, "Member 'UEngine::VertexColorViewModeMaterialName_ColorOnly' has a wrong offset!");
static_assert(offsetof(UEngine, VertexColorViewModeMaterial_AlphaAsColor) == 0x0005D8, "Member 'UEngine::VertexColorViewModeMaterial_AlphaAsColor' has a wrong offset!");
static_assert(offsetof(UEngine, VertexColorViewModeMaterialName_AlphaAsColor) == 0x0005E0, "Member 'UEngine::VertexColorViewModeMaterialName_AlphaAsColor' has a wrong offset!");
static_assert(offsetof(UEngine, VertexColorViewModeMaterial_RedOnly) == 0x0005F0, "Member 'UEngine::VertexColorViewModeMaterial_RedOnly' has a wrong offset!");
static_assert(offsetof(UEngine, VertexColorViewModeMaterialName_RedOnly) == 0x0005F8, "Member 'UEngine::VertexColorViewModeMaterialName_RedOnly' has a wrong offset!");
static_assert(offsetof(UEngine, VertexColorViewModeMaterial_GreenOnly) == 0x000608, "Member 'UEngine::VertexColorViewModeMaterial_GreenOnly' has a wrong offset!");
static_assert(offsetof(UEngine, VertexColorViewModeMaterialName_GreenOnly) == 0x000610, "Member 'UEngine::VertexColorViewModeMaterialName_GreenOnly' has a wrong offset!");
static_assert(offsetof(UEngine, VertexColorViewModeMaterial_BlueOnly) == 0x000620, "Member 'UEngine::VertexColorViewModeMaterial_BlueOnly' has a wrong offset!");
static_assert(offsetof(UEngine, VertexColorViewModeMaterialName_BlueOnly) == 0x000628, "Member 'UEngine::VertexColorViewModeMaterialName_BlueOnly' has a wrong offset!");
static_assert(offsetof(UEngine, DebugEditorMaterialName) == 0x000638, "Member 'UEngine::DebugEditorMaterialName' has a wrong offset!");
static_assert(offsetof(UEngine, ConstraintLimitMaterial) == 0x000658, "Member 'UEngine::ConstraintLimitMaterial' has a wrong offset!");
static_assert(offsetof(UEngine, ConstraintLimitMaterialX) == 0x000660, "Member 'UEngine::ConstraintLimitMaterialX' has a wrong offset!");
static_assert(offsetof(UEngine, ConstraintLimitMaterialXAxis) == 0x000668, "Member 'UEngine::ConstraintLimitMaterialXAxis' has a wrong offset!");
static_assert(offsetof(UEngine, ConstraintLimitMaterialY) == 0x000670, "Member 'UEngine::ConstraintLimitMaterialY' has a wrong offset!");
static_assert(offsetof(UEngine, ConstraintLimitMaterialYAxis) == 0x000678, "Member 'UEngine::ConstraintLimitMaterialYAxis' has a wrong offset!");
static_assert(offsetof(UEngine, ConstraintLimitMaterialZ) == 0x000680, "Member 'UEngine::ConstraintLimitMaterialZ' has a wrong offset!");
static_assert(offsetof(UEngine, ConstraintLimitMaterialZAxis) == 0x000688, "Member 'UEngine::ConstraintLimitMaterialZAxis' has a wrong offset!");
static_assert(offsetof(UEngine, ConstraintLimitMaterialPrismatic) == 0x000690, "Member 'UEngine::ConstraintLimitMaterialPrismatic' has a wrong offset!");
static_assert(offsetof(UEngine, InvalidLightmapSettingsMaterial) == 0x000698, "Member 'UEngine::InvalidLightmapSettingsMaterial' has a wrong offset!");
static_assert(offsetof(UEngine, InvalidLightmapSettingsMaterialName) == 0x0006A0, "Member 'UEngine::InvalidLightmapSettingsMaterialName' has a wrong offset!");
static_assert(offsetof(UEngine, PreviewShadowsIndicatorMaterial) == 0x0006C0, "Member 'UEngine::PreviewShadowsIndicatorMaterial' has a wrong offset!");
static_assert(offsetof(UEngine, PreviewShadowsIndicatorMaterialName) == 0x0006C8, "Member 'UEngine::PreviewShadowsIndicatorMaterialName' has a wrong offset!");
static_assert(offsetof(UEngine, ArrowMaterial) == 0x0006E8, "Member 'UEngine::ArrowMaterial' has a wrong offset!");
static_assert(offsetof(UEngine, ArrowMaterialYellow) == 0x0006F0, "Member 'UEngine::ArrowMaterialYellow' has a wrong offset!");
static_assert(offsetof(UEngine, ArrowMaterialName) == 0x0006F8, "Member 'UEngine::ArrowMaterialName' has a wrong offset!");
static_assert(offsetof(UEngine, LightingOnlyBrightness) == 0x000718, "Member 'UEngine::LightingOnlyBrightness' has a wrong offset!");
static_assert(offsetof(UEngine, ShaderComplexityColors) == 0x000728, "Member 'UEngine::ShaderComplexityColors' has a wrong offset!");
static_assert(offsetof(UEngine, QuadComplexityColors) == 0x000738, "Member 'UEngine::QuadComplexityColors' has a wrong offset!");
static_assert(offsetof(UEngine, LightComplexityColors) == 0x000748, "Member 'UEngine::LightComplexityColors' has a wrong offset!");
static_assert(offsetof(UEngine, StationaryLightOverlapColors) == 0x000758, "Member 'UEngine::StationaryLightOverlapColors' has a wrong offset!");
static_assert(offsetof(UEngine, LODColorationColors) == 0x000768, "Member 'UEngine::LODColorationColors' has a wrong offset!");
static_assert(offsetof(UEngine, HLODColorationColors) == 0x000778, "Member 'UEngine::HLODColorationColors' has a wrong offset!");
static_assert(offsetof(UEngine, StreamingAccuracyColors) == 0x000788, "Member 'UEngine::StreamingAccuracyColors' has a wrong offset!");
static_assert(offsetof(UEngine, GPUSkinCacheVisualizationExcludedColor) == 0x000798, "Member 'UEngine::GPUSkinCacheVisualizationExcludedColor' has a wrong offset!");
static_assert(offsetof(UEngine, GPUSkinCacheVisualizationIncludedColor) == 0x0007A8, "Member 'UEngine::GPUSkinCacheVisualizationIncludedColor' has a wrong offset!");
static_assert(offsetof(UEngine, GPUSkinCacheVisualizationRecomputeTangentsColor) == 0x0007B8, "Member 'UEngine::GPUSkinCacheVisualizationRecomputeTangentsColor' has a wrong offset!");
static_assert(offsetof(UEngine, GPUSkinCacheVisualizationLowMemoryThresholdInMB) == 0x0007C8, "Member 'UEngine::GPUSkinCacheVisualizationLowMemoryThresholdInMB' has a wrong offset!");
static_assert(offsetof(UEngine, GPUSkinCacheVisualizationHighMemoryThresholdInMB) == 0x0007CC, "Member 'UEngine::GPUSkinCacheVisualizationHighMemoryThresholdInMB' has a wrong offset!");
static_assert(offsetof(UEngine, GPUSkinCacheVisualizationLowMemoryColor) == 0x0007D0, "Member 'UEngine::GPUSkinCacheVisualizationLowMemoryColor' has a wrong offset!");
static_assert(offsetof(UEngine, GPUSkinCacheVisualizationMidMemoryColor) == 0x0007E0, "Member 'UEngine::GPUSkinCacheVisualizationMidMemoryColor' has a wrong offset!");
static_assert(offsetof(UEngine, GPUSkinCacheVisualizationHighMemoryColor) == 0x0007F0, "Member 'UEngine::GPUSkinCacheVisualizationHighMemoryColor' has a wrong offset!");
static_assert(offsetof(UEngine, GPUSkinCacheVisualizationRayTracingLODOffsetColors) == 0x000800, "Member 'UEngine::GPUSkinCacheVisualizationRayTracingLODOffsetColors' has a wrong offset!");
static_assert(offsetof(UEngine, MaxPixelShaderAdditiveComplexityCount) == 0x000810, "Member 'UEngine::MaxPixelShaderAdditiveComplexityCount' has a wrong offset!");
static_assert(offsetof(UEngine, MaxES3PixelShaderAdditiveComplexityCount) == 0x000814, "Member 'UEngine::MaxES3PixelShaderAdditiveComplexityCount' has a wrong offset!");
static_assert(offsetof(UEngine, MinLightMapDensity) == 0x000818, "Member 'UEngine::MinLightMapDensity' has a wrong offset!");
static_assert(offsetof(UEngine, IdealLightMapDensity) == 0x00081C, "Member 'UEngine::IdealLightMapDensity' has a wrong offset!");
static_assert(offsetof(UEngine, MaxLightMapDensity) == 0x000820, "Member 'UEngine::MaxLightMapDensity' has a wrong offset!");
static_assert(offsetof(UEngine, RenderLightMapDensityGrayscaleScale) == 0x000828, "Member 'UEngine::RenderLightMapDensityGrayscaleScale' has a wrong offset!");
static_assert(offsetof(UEngine, RenderLightMapDensityColorScale) == 0x00082C, "Member 'UEngine::RenderLightMapDensityColorScale' has a wrong offset!");
static_assert(offsetof(UEngine, LightMapDensityVertexMappedColor) == 0x000830, "Member 'UEngine::LightMapDensityVertexMappedColor' has a wrong offset!");
static_assert(offsetof(UEngine, LightMapDensitySelectedColor) == 0x000840, "Member 'UEngine::LightMapDensitySelectedColor' has a wrong offset!");
static_assert(offsetof(UEngine, StatColorMappings) == 0x000850, "Member 'UEngine::StatColorMappings' has a wrong offset!");
static_assert(offsetof(UEngine, DefaultPhysMaterial) == 0x000860, "Member 'UEngine::DefaultPhysMaterial' has a wrong offset!");
static_assert(offsetof(UEngine, DefaultPhysMaterialName) == 0x000868, "Member 'UEngine::DefaultPhysMaterialName' has a wrong offset!");
static_assert(offsetof(UEngine, DefaultDestructiblePhysMaterial) == 0x000888, "Member 'UEngine::DefaultDestructiblePhysMaterial' has a wrong offset!");
static_assert(offsetof(UEngine, DefaultDestructiblePhysMaterialName) == 0x000890, "Member 'UEngine::DefaultDestructiblePhysMaterialName' has a wrong offset!");
static_assert(offsetof(UEngine, ActiveGameNameRedirects) == 0x0008B0, "Member 'UEngine::ActiveGameNameRedirects' has a wrong offset!");
static_assert(offsetof(UEngine, ActiveClassRedirects) == 0x0008C0, "Member 'UEngine::ActiveClassRedirects' has a wrong offset!");
static_assert(offsetof(UEngine, ActivePluginRedirects) == 0x0008D0, "Member 'UEngine::ActivePluginRedirects' has a wrong offset!");
static_assert(offsetof(UEngine, ActiveStructRedirects) == 0x0008E0, "Member 'UEngine::ActiveStructRedirects' has a wrong offset!");
static_assert(offsetof(UEngine, PreIntegratedSkinBRDFTexture) == 0x0008F0, "Member 'UEngine::PreIntegratedSkinBRDFTexture' has a wrong offset!");
static_assert(offsetof(UEngine, PreIntegratedSkinBRDFTextureName) == 0x0008F8, "Member 'UEngine::PreIntegratedSkinBRDFTextureName' has a wrong offset!");
static_assert(offsetof(UEngine, BlueNoiseScalarTexture) == 0x000918, "Member 'UEngine::BlueNoiseScalarTexture' has a wrong offset!");
static_assert(offsetof(UEngine, BlueNoiseVec2Texture) == 0x000920, "Member 'UEngine::BlueNoiseVec2Texture' has a wrong offset!");
static_assert(offsetof(UEngine, BlueNoiseScalarTextureName) == 0x000928, "Member 'UEngine::BlueNoiseScalarTextureName' has a wrong offset!");
static_assert(offsetof(UEngine, BlueNoiseVec2TextureName) == 0x000948, "Member 'UEngine::BlueNoiseVec2TextureName' has a wrong offset!");
static_assert(offsetof(UEngine, GlintTexture) == 0x000968, "Member 'UEngine::GlintTexture' has a wrong offset!");
static_assert(offsetof(UEngine, GlintTexture2) == 0x000970, "Member 'UEngine::GlintTexture2' has a wrong offset!");
static_assert(offsetof(UEngine, GlintTextureName) == 0x000978, "Member 'UEngine::GlintTextureName' has a wrong offset!");
static_assert(offsetof(UEngine, GlintTexture2Name) == 0x000998, "Member 'UEngine::GlintTexture2Name' has a wrong offset!");
static_assert(offsetof(UEngine, SimpleVolumeTexture) == 0x0009B8, "Member 'UEngine::SimpleVolumeTexture' has a wrong offset!");
static_assert(offsetof(UEngine, SimpleVolumeTextureName) == 0x0009C0, "Member 'UEngine::SimpleVolumeTextureName' has a wrong offset!");
static_assert(offsetof(UEngine, SimpleVolumeEnvTexture) == 0x0009E0, "Member 'UEngine::SimpleVolumeEnvTexture' has a wrong offset!");
static_assert(offsetof(UEngine, SimpleVolumeEnvTextureName) == 0x0009E8, "Member 'UEngine::SimpleVolumeEnvTextureName' has a wrong offset!");
static_assert(offsetof(UEngine, MiniFontTexture) == 0x000A08, "Member 'UEngine::MiniFontTexture' has a wrong offset!");
static_assert(offsetof(UEngine, MiniFontTextureName) == 0x000A10, "Member 'UEngine::MiniFontTextureName' has a wrong offset!");
static_assert(offsetof(UEngine, WeightMapPlaceholderTexture) == 0x000A30, "Member 'UEngine::WeightMapPlaceholderTexture' has a wrong offset!");
static_assert(offsetof(UEngine, WeightMapPlaceholderTextureName) == 0x000A38, "Member 'UEngine::WeightMapPlaceholderTextureName' has a wrong offset!");
static_assert(offsetof(UEngine, LightMapDensityTexture) == 0x000A58, "Member 'UEngine::LightMapDensityTexture' has a wrong offset!");
static_assert(offsetof(UEngine, LightMapDensityTextureName) == 0x000A60, "Member 'UEngine::LightMapDensityTextureName' has a wrong offset!");
static_assert(offsetof(UEngine, GameViewport) == 0x000A88, "Member 'UEngine::GameViewport' has a wrong offset!");
static_assert(offsetof(UEngine, DeferredCommands) == 0x000A90, "Member 'UEngine::DeferredCommands' has a wrong offset!");
static_assert(offsetof(UEngine, NearClipPlane) == 0x000AA0, "Member 'UEngine::NearClipPlane' has a wrong offset!");
static_assert(offsetof(UEngine, MaximumLoopIterationCount) == 0x000AA8, "Member 'UEngine::MaximumLoopIterationCount' has a wrong offset!");
static_assert(offsetof(UEngine, FixedFrameRate) == 0x000AB0, "Member 'UEngine::FixedFrameRate' has a wrong offset!");
static_assert(offsetof(UEngine, SmoothedFrameRateRange) == 0x000AB4, "Member 'UEngine::SmoothedFrameRateRange' has a wrong offset!");
static_assert(offsetof(UEngine, CustomTimeStep) == 0x000AC8, "Member 'UEngine::CustomTimeStep' has a wrong offset!");
static_assert(offsetof(UEngine, CustomTimeStepClassName) == 0x000AF0, "Member 'UEngine::CustomTimeStepClassName' has a wrong offset!");
static_assert(offsetof(UEngine, TimecodeProvider) == 0x000B10, "Member 'UEngine::TimecodeProvider' has a wrong offset!");
static_assert(offsetof(UEngine, TimecodeProviderClassName) == 0x000B38, "Member 'UEngine::TimecodeProviderClassName' has a wrong offset!");
static_assert(offsetof(UEngine, bGenerateDefaultTimecode) == 0x000B58, "Member 'UEngine::bGenerateDefaultTimecode' has a wrong offset!");
static_assert(offsetof(UEngine, GenerateDefaultTimecodeFrameRate) == 0x000B5C, "Member 'UEngine::GenerateDefaultTimecodeFrameRate' has a wrong offset!");
static_assert(offsetof(UEngine, GenerateDefaultTimecodeFrameDelay) == 0x000B64, "Member 'UEngine::GenerateDefaultTimecodeFrameDelay' has a wrong offset!");
static_assert(offsetof(UEngine, NumPawnsAllowedToBeSpawnedInAFrame) == 0x000B6C, "Member 'UEngine::NumPawnsAllowedToBeSpawnedInAFrame' has a wrong offset!");
static_assert(offsetof(UEngine, C_WorldBox) == 0x000B74, "Member 'UEngine::C_WorldBox' has a wrong offset!");
static_assert(offsetof(UEngine, C_BrushWire) == 0x000B78, "Member 'UEngine::C_BrushWire' has a wrong offset!");
static_assert(offsetof(UEngine, C_AddWire) == 0x000B7C, "Member 'UEngine::C_AddWire' has a wrong offset!");
static_assert(offsetof(UEngine, C_SubtractWire) == 0x000B80, "Member 'UEngine::C_SubtractWire' has a wrong offset!");
static_assert(offsetof(UEngine, C_SemiSolidWire) == 0x000B84, "Member 'UEngine::C_SemiSolidWire' has a wrong offset!");
static_assert(offsetof(UEngine, C_NonSolidWire) == 0x000B88, "Member 'UEngine::C_NonSolidWire' has a wrong offset!");
static_assert(offsetof(UEngine, C_WireBackground) == 0x000B8C, "Member 'UEngine::C_WireBackground' has a wrong offset!");
static_assert(offsetof(UEngine, C_ScaleBoxHi) == 0x000B90, "Member 'UEngine::C_ScaleBoxHi' has a wrong offset!");
static_assert(offsetof(UEngine, C_VolumeCollision) == 0x000B94, "Member 'UEngine::C_VolumeCollision' has a wrong offset!");
static_assert(offsetof(UEngine, C_BSPCollision) == 0x000B98, "Member 'UEngine::C_BSPCollision' has a wrong offset!");
static_assert(offsetof(UEngine, C_OrthoBackground) == 0x000B9C, "Member 'UEngine::C_OrthoBackground' has a wrong offset!");
static_assert(offsetof(UEngine, C_Volume) == 0x000BA0, "Member 'UEngine::C_Volume' has a wrong offset!");
static_assert(offsetof(UEngine, C_BrushShape) == 0x000BA4, "Member 'UEngine::C_BrushShape' has a wrong offset!");
static_assert(offsetof(UEngine, GameScreenshotSaveDirectory) == 0x000BB0, "Member 'UEngine::GameScreenshotSaveDirectory' has a wrong offset!");
static_assert(offsetof(UEngine, UseStaticMeshMinLODPerQualityLevels) == 0x000BC0, "Member 'UEngine::UseStaticMeshMinLODPerQualityLevels' has a wrong offset!");
static_assert(offsetof(UEngine, UseSkeletalMeshMinLODPerQualityLevels) == 0x000BC1, "Member 'UEngine::UseSkeletalMeshMinLODPerQualityLevels' has a wrong offset!");
static_assert(offsetof(UEngine, UseGrassVarityPerQualityLevels) == 0x000BC2, "Member 'UEngine::UseGrassVarityPerQualityLevels' has a wrong offset!");
static_assert(offsetof(UEngine, TransitionType) == 0x000BC3, "Member 'UEngine::TransitionType' has a wrong offset!");
static_assert(offsetof(UEngine, TransitionDescription) == 0x000BC8, "Member 'UEngine::TransitionDescription' has a wrong offset!");
static_assert(offsetof(UEngine, TransitionGameMode) == 0x000BD8, "Member 'UEngine::TransitionGameMode' has a wrong offset!");
static_assert(offsetof(UEngine, CameraRotationThreshold) == 0x000BEC, "Member 'UEngine::CameraRotationThreshold' has a wrong offset!");
static_assert(offsetof(UEngine, CameraTranslationThreshold) == 0x000BF0, "Member 'UEngine::CameraTranslationThreshold' has a wrong offset!");
static_assert(offsetof(UEngine, PrimitiveProbablyVisibleTime) == 0x000BF4, "Member 'UEngine::PrimitiveProbablyVisibleTime' has a wrong offset!");
static_assert(offsetof(UEngine, MaxOcclusionPixelsFraction) == 0x000BF8, "Member 'UEngine::MaxOcclusionPixelsFraction' has a wrong offset!");
static_assert(offsetof(UEngine, MaxParticleResize) == 0x000C00, "Member 'UEngine::MaxParticleResize' has a wrong offset!");
static_assert(offsetof(UEngine, MaxParticleResizeWarn) == 0x000C04, "Member 'UEngine::MaxParticleResizeWarn' has a wrong offset!");
static_assert(offsetof(UEngine, PendingDroppedNotes) == 0x000C08, "Member 'UEngine::PendingDroppedNotes' has a wrong offset!");
static_assert(offsetof(UEngine, NetClientTicksPerSecond) == 0x000C18, "Member 'UEngine::NetClientTicksPerSecond' has a wrong offset!");
static_assert(offsetof(UEngine, DisplayGamma) == 0x000C1C, "Member 'UEngine::DisplayGamma' has a wrong offset!");
static_assert(offsetof(UEngine, MinDesiredFrameRate) == 0x000C20, "Member 'UEngine::MinDesiredFrameRate' has a wrong offset!");
static_assert(offsetof(UEngine, DefaultSelectedMaterialColor) == 0x000C24, "Member 'UEngine::DefaultSelectedMaterialColor' has a wrong offset!");
static_assert(offsetof(UEngine, SelectedMaterialColor) == 0x000C34, "Member 'UEngine::SelectedMaterialColor' has a wrong offset!");
static_assert(offsetof(UEngine, SelectionOutlineColor) == 0x000C44, "Member 'UEngine::SelectionOutlineColor' has a wrong offset!");
static_assert(offsetof(UEngine, SubduedSelectionOutlineColor) == 0x000C54, "Member 'UEngine::SubduedSelectionOutlineColor' has a wrong offset!");
static_assert(offsetof(UEngine, SelectedMaterialColorOverride) == 0x000C64, "Member 'UEngine::SelectedMaterialColorOverride' has a wrong offset!");
static_assert(offsetof(UEngine, bIsOverridingSelectedColor) == 0x000C74, "Member 'UEngine::bIsOverridingSelectedColor' has a wrong offset!");
static_assert(offsetof(UEngine, bEnableVisualLogRecordingOnStart) == 0x000C7C, "Member 'UEngine::bEnableVisualLogRecordingOnStart' has a wrong offset!");
static_assert(offsetof(UEngine, ScreenSaverInhibitorSemaphore) == 0x000C80, "Member 'UEngine::ScreenSaverInhibitorSemaphore' has a wrong offset!");
static_assert(offsetof(UEngine, ParticleEventManagerClassPath) == 0x000C88, "Member 'UEngine::ParticleEventManagerClassPath' has a wrong offset!");
static_assert(offsetof(UEngine, SelectionHighlightIntensity) == 0x000C98, "Member 'UEngine::SelectionHighlightIntensity' has a wrong offset!");
static_assert(offsetof(UEngine, BSPSelectionHighlightIntensity) == 0x000C9C, "Member 'UEngine::BSPSelectionHighlightIntensity' has a wrong offset!");
static_assert(offsetof(UEngine, SelectionHighlightIntensityBillboards) == 0x000CA0, "Member 'UEngine::SelectionHighlightIntensityBillboards' has a wrong offset!");
static_assert(offsetof(UEngine, GlobalNetTravelCount) == 0x000F38, "Member 'UEngine::GlobalNetTravelCount' has a wrong offset!");
static_assert(offsetof(UEngine, NetDriverDefinitions) == 0x000F40, "Member 'UEngine::NetDriverDefinitions' has a wrong offset!");
static_assert(offsetof(UEngine, IrisNetDriverConfigs) == 0x000F50, "Member 'UEngine::IrisNetDriverConfigs' has a wrong offset!");
static_assert(offsetof(UEngine, ServerActors) == 0x000F60, "Member 'UEngine::ServerActors' has a wrong offset!");
static_assert(offsetof(UEngine, RuntimeServerActors) == 0x000F70, "Member 'UEngine::RuntimeServerActors' has a wrong offset!");
static_assert(offsetof(UEngine, NetErrorLogInterval) == 0x000F80, "Member 'UEngine::NetErrorLogInterval' has a wrong offset!");
static_assert(offsetof(UEngine, NextWorldContextHandle) == 0x000FC0, "Member 'UEngine::NextWorldContextHandle' has a wrong offset!");

// Class Engine.GameEngine
// 0x0058 (0x1100 - 0x10A8)
class UGameEngine final : public UEngine
{
public:
	float                                         MaxDeltaTime;                                      // 0x10A8(0x0004)(ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         ServerFlushLogInterval;                            // 0x10AC(0x0004)(ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UGameInstance*                          GameInstance;                                      // 0x10B0(0x0008)(ZeroConstructor, Transient, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_10B8[0x48];                                    // 0x10B8(0x0048)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UGameEngine* GetEngine();

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"GameEngine">();
	}
	static class UGameEngine* GetDefaultObj()
	{
		return GetDefaultObjImpl<UGameEngine>();
	}
};
static_assert(alignof(UGameEngine) == 0x000008, "Wrong alignment on UGameEngine");
static_assert(sizeof(UGameEngine) == 0x001100, "Wrong size on UGameEngine");
static_assert(offsetof(UGameEngine, MaxDeltaTime) == 0x0010A8, "Member 'UGameEngine::MaxDeltaTime' has a wrong offset!");
static_assert(offsetof(UGameEngine, ServerFlushLogInterval) == 0x0010AC, "Member 'UGameEngine::ServerFlushLogInterval' has a wrong offset!");
static_assert(offsetof(UGameEngine, GameInstance) == 0x0010B0, "Member 'UGameEngine::GameInstance' has a wrong offset!");

// Class Engine.SoundNodeConcatenator
// 0x0010 (0x0058 - 0x0048)
class USoundNodeConcatenator final : public USoundNode
{
public:
	TArray<float>                                 InputVolume;                                       // 0x0048(0x0010)(Edit, EditFixedSize, ZeroConstructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"SoundNodeConcatenator">();
	}
	static class USoundNodeConcatenator* GetDefaultObj()
	{
		return GetDefaultObjImpl<USoundNodeConcatenator>();
	}
};
static_assert(alignof(USoundNodeConcatenator) == 0x000008, "Wrong alignment on USoundNodeConcatenator");
static_assert(sizeof(USoundNodeConcatenator) == 0x000058, "Wrong size on USoundNodeConcatenator");
static_assert(offsetof(USoundNodeConcatenator, InputVolume) == 0x000048, "Member 'USoundNodeConcatenator::InputVolume' has a wrong offset!");

// Class Engine.MaterialExpressionOneMinus
// 0x0028 (0x00D8 - 0x00B0)
class UMaterialExpressionOneMinus final : public UMaterialExpression
{
public:
	struct FExpressionInput                       Input;                                             // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionOneMinus">();
	}
	static class UMaterialExpressionOneMinus* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionOneMinus>();
	}
};
static_assert(alignof(UMaterialExpressionOneMinus) == 0x000008, "Wrong alignment on UMaterialExpressionOneMinus");
static_assert(sizeof(UMaterialExpressionOneMinus) == 0x0000D8, "Wrong size on UMaterialExpressionOneMinus");
static_assert(offsetof(UMaterialExpressionOneMinus, Input) == 0x0000B0, "Member 'UMaterialExpressionOneMinus::Input' has a wrong offset!");

// Class Engine.RawAnimSequenceTrackExtensions
// 0x0000 (0x0028 - 0x0028)
class URawAnimSequenceTrackExtensions final : public UBlueprintFunctionLibrary
{
public:
	static TArray<struct FVector> GetPositionalKeys(const struct FRawAnimSequenceTrack& Track);
	static TArray<struct FQuat> GetRotationalKeys(const struct FRawAnimSequenceTrack& Track);
	static TArray<struct FVector> GetScaleKeys(const struct FRawAnimSequenceTrack& Track);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"RawAnimSequenceTrackExtensions">();
	}
	static class URawAnimSequenceTrackExtensions* GetDefaultObj()
	{
		return GetDefaultObjImpl<URawAnimSequenceTrackExtensions>();
	}
};
static_assert(alignof(URawAnimSequenceTrackExtensions) == 0x000008, "Wrong alignment on URawAnimSequenceTrackExtensions");
static_assert(sizeof(URawAnimSequenceTrackExtensions) == 0x000028, "Wrong size on URawAnimSequenceTrackExtensions");

// Class Engine.AssetExportTask
// 0x0050 (0x0078 - 0x0028)
class UAssetExportTask final : public UObject
{
public:
	class UObject*                                Object;                                            // 0x0028(0x0008)(BlueprintVisible, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UExporter*                              Exporter;                                          // 0x0030(0x0008)(BlueprintVisible, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FString                                 Filename;                                          // 0x0038(0x0010)(BlueprintVisible, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bSelected;                                         // 0x0048(0x0001)(BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bReplaceIdentical;                                 // 0x0049(0x0001)(BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bPrompt;                                           // 0x004A(0x0001)(BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bAutomated;                                        // 0x004B(0x0001)(BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bUseFileArchive;                                   // 0x004C(0x0001)(BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bWriteEmptyFiles;                                  // 0x004D(0x0001)(BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_4E[0x2];                                       // 0x004E(0x0002)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<class UObject*>                        IgnoreObjectList;                                  // 0x0050(0x0010)(BlueprintVisible, ZeroConstructor, UObjectWrapper, NativeAccessSpecifierPublic)
	class UObject*                                OPTIONS;                                           // 0x0060(0x0008)(BlueprintVisible, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TArray<class FString>                         Errors;                                            // 0x0068(0x0010)(BlueprintVisible, ZeroConstructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AssetExportTask">();
	}
	static class UAssetExportTask* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAssetExportTask>();
	}
};
static_assert(alignof(UAssetExportTask) == 0x000008, "Wrong alignment on UAssetExportTask");
static_assert(sizeof(UAssetExportTask) == 0x000078, "Wrong size on UAssetExportTask");
static_assert(offsetof(UAssetExportTask, Object) == 0x000028, "Member 'UAssetExportTask::Object' has a wrong offset!");
static_assert(offsetof(UAssetExportTask, Exporter) == 0x000030, "Member 'UAssetExportTask::Exporter' has a wrong offset!");
static_assert(offsetof(UAssetExportTask, Filename) == 0x000038, "Member 'UAssetExportTask::Filename' has a wrong offset!");
static_assert(offsetof(UAssetExportTask, bSelected) == 0x000048, "Member 'UAssetExportTask::bSelected' has a wrong offset!");
static_assert(offsetof(UAssetExportTask, bReplaceIdentical) == 0x000049, "Member 'UAssetExportTask::bReplaceIdentical' has a wrong offset!");
static_assert(offsetof(UAssetExportTask, bPrompt) == 0x00004A, "Member 'UAssetExportTask::bPrompt' has a wrong offset!");
static_assert(offsetof(UAssetExportTask, bAutomated) == 0x00004B, "Member 'UAssetExportTask::bAutomated' has a wrong offset!");
static_assert(offsetof(UAssetExportTask, bUseFileArchive) == 0x00004C, "Member 'UAssetExportTask::bUseFileArchive' has a wrong offset!");
static_assert(offsetof(UAssetExportTask, bWriteEmptyFiles) == 0x00004D, "Member 'UAssetExportTask::bWriteEmptyFiles' has a wrong offset!");
static_assert(offsetof(UAssetExportTask, IgnoreObjectList) == 0x000050, "Member 'UAssetExportTask::IgnoreObjectList' has a wrong offset!");
static_assert(offsetof(UAssetExportTask, OPTIONS) == 0x000060, "Member 'UAssetExportTask::OPTIONS' has a wrong offset!");
static_assert(offsetof(UAssetExportTask, Errors) == 0x000068, "Member 'UAssetExportTask::Errors' has a wrong offset!");

// Class Engine.AnimNotifyState_DisableRootMotion
// 0x0000 (0x0030 - 0x0030)
class UAnimNotifyState_DisableRootMotion final : public UAnimNotifyState
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AnimNotifyState_DisableRootMotion">();
	}
	static class UAnimNotifyState_DisableRootMotion* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAnimNotifyState_DisableRootMotion>();
	}
};
static_assert(alignof(UAnimNotifyState_DisableRootMotion) == 0x000008, "Wrong alignment on UAnimNotifyState_DisableRootMotion");
static_assert(sizeof(UAnimNotifyState_DisableRootMotion) == 0x000030, "Wrong size on UAnimNotifyState_DisableRootMotion");

// Class Engine.MaterialExpressionConstant
// 0x0008 (0x00B8 - 0x00B0)
class UMaterialExpressionConstant final : public UMaterialExpression
{
public:
	float                                         R;                                                 // 0x00B0(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_B4[0x4];                                       // 0x00B4(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionConstant">();
	}
	static class UMaterialExpressionConstant* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionConstant>();
	}
};
static_assert(alignof(UMaterialExpressionConstant) == 0x000008, "Wrong alignment on UMaterialExpressionConstant");
static_assert(sizeof(UMaterialExpressionConstant) == 0x0000B8, "Wrong size on UMaterialExpressionConstant");
static_assert(offsetof(UMaterialExpressionConstant, R) == 0x0000B0, "Member 'UMaterialExpressionConstant::R' has a wrong offset!");

// Class Engine.AssetManagerSettings
// 0x00C8 (0x0100 - 0x0038)
class UAssetManagerSettings final : public UDeveloperSettings
{
public:
	TArray<struct FPrimaryAssetTypeInfo>          PrimaryAssetTypesToScan;                           // 0x0038(0x0010)(Edit, ZeroConstructor, Config, NativeAccessSpecifierPublic)
	TArray<struct FDirectoryPath>                 DirectoriesToExclude;                              // 0x0048(0x0010)(Edit, ZeroConstructor, Config, NativeAccessSpecifierPublic)
	TArray<struct FPrimaryAssetRulesOverride>     PrimaryAssetRules;                                 // 0x0058(0x0010)(Edit, ZeroConstructor, Config, NativeAccessSpecifierPublic)
	TArray<struct FPrimaryAssetRulesCustomOverride> CustomPrimaryAssetRules;                         // 0x0068(0x0010)(Edit, ZeroConstructor, Config, NativeAccessSpecifierPublic)
	bool                                          bOnlyCookProductionAssets;                         // 0x0078(0x0001)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bShouldManagerDetermineTypeAndName;                // 0x0079(0x0001)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bShouldGuessTypeAndNameInEditor;                   // 0x007A(0x0001)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bShouldAcquireMissingChunksOnLoad;                 // 0x007B(0x0001)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bShouldWarnAboutInvalidAssets;                     // 0x007C(0x0001)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_7D[0x3];                                       // 0x007D(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<struct FAssetManagerRedirect>          PrimaryAssetIdRedirects;                           // 0x0080(0x0010)(Edit, ZeroConstructor, Config, NativeAccessSpecifierPublic)
	TArray<struct FAssetManagerRedirect>          PrimaryAssetTypeRedirects;                         // 0x0090(0x0010)(Edit, ZeroConstructor, Config, NativeAccessSpecifierPublic)
	TArray<struct FAssetManagerRedirect>          AssetPathRedirects;                                // 0x00A0(0x0010)(Edit, ZeroConstructor, Config, NativeAccessSpecifierPublic)
	TSet<class FName>                             MetaDataTagsForAssetRegistry;                      // 0x00B0(0x0050)(Edit, Config, AdvancedDisplay, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AssetManagerSettings">();
	}
	static class UAssetManagerSettings* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAssetManagerSettings>();
	}
};
static_assert(alignof(UAssetManagerSettings) == 0x000008, "Wrong alignment on UAssetManagerSettings");
static_assert(sizeof(UAssetManagerSettings) == 0x000100, "Wrong size on UAssetManagerSettings");
static_assert(offsetof(UAssetManagerSettings, PrimaryAssetTypesToScan) == 0x000038, "Member 'UAssetManagerSettings::PrimaryAssetTypesToScan' has a wrong offset!");
static_assert(offsetof(UAssetManagerSettings, DirectoriesToExclude) == 0x000048, "Member 'UAssetManagerSettings::DirectoriesToExclude' has a wrong offset!");
static_assert(offsetof(UAssetManagerSettings, PrimaryAssetRules) == 0x000058, "Member 'UAssetManagerSettings::PrimaryAssetRules' has a wrong offset!");
static_assert(offsetof(UAssetManagerSettings, CustomPrimaryAssetRules) == 0x000068, "Member 'UAssetManagerSettings::CustomPrimaryAssetRules' has a wrong offset!");
static_assert(offsetof(UAssetManagerSettings, bOnlyCookProductionAssets) == 0x000078, "Member 'UAssetManagerSettings::bOnlyCookProductionAssets' has a wrong offset!");
static_assert(offsetof(UAssetManagerSettings, bShouldManagerDetermineTypeAndName) == 0x000079, "Member 'UAssetManagerSettings::bShouldManagerDetermineTypeAndName' has a wrong offset!");
static_assert(offsetof(UAssetManagerSettings, bShouldGuessTypeAndNameInEditor) == 0x00007A, "Member 'UAssetManagerSettings::bShouldGuessTypeAndNameInEditor' has a wrong offset!");
static_assert(offsetof(UAssetManagerSettings, bShouldAcquireMissingChunksOnLoad) == 0x00007B, "Member 'UAssetManagerSettings::bShouldAcquireMissingChunksOnLoad' has a wrong offset!");
static_assert(offsetof(UAssetManagerSettings, bShouldWarnAboutInvalidAssets) == 0x00007C, "Member 'UAssetManagerSettings::bShouldWarnAboutInvalidAssets' has a wrong offset!");
static_assert(offsetof(UAssetManagerSettings, PrimaryAssetIdRedirects) == 0x000080, "Member 'UAssetManagerSettings::PrimaryAssetIdRedirects' has a wrong offset!");
static_assert(offsetof(UAssetManagerSettings, PrimaryAssetTypeRedirects) == 0x000090, "Member 'UAssetManagerSettings::PrimaryAssetTypeRedirects' has a wrong offset!");
static_assert(offsetof(UAssetManagerSettings, AssetPathRedirects) == 0x0000A0, "Member 'UAssetManagerSettings::AssetPathRedirects' has a wrong offset!");
static_assert(offsetof(UAssetManagerSettings, MetaDataTagsForAssetRegistry) == 0x0000B0, "Member 'UAssetManagerSettings::MetaDataTagsForAssetRegistry' has a wrong offset!");

// Class Engine.BoneMaskFilter
// 0x0010 (0x0038 - 0x0028)
class UBoneMaskFilter final : public UObject
{
public:
	TArray<struct FInputBlendPose>                BlendPoses;                                        // 0x0028(0x0010)(Edit, ZeroConstructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"BoneMaskFilter">();
	}
	static class UBoneMaskFilter* GetDefaultObj()
	{
		return GetDefaultObjImpl<UBoneMaskFilter>();
	}
};
static_assert(alignof(UBoneMaskFilter) == 0x000008, "Wrong alignment on UBoneMaskFilter");
static_assert(sizeof(UBoneMaskFilter) == 0x000038, "Wrong size on UBoneMaskFilter");
static_assert(offsetof(UBoneMaskFilter, BlendPoses) == 0x000028, "Member 'UBoneMaskFilter::BlendPoses' has a wrong offset!");

// Class Engine.AsyncPhysicsData
// 0x0008 (0x0030 - 0x0028)
class UAsyncPhysicsData final : public UObject
{
public:
	int32                                         ServerFrame;                                       // 0x0028(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	int32                                         ReplicationRedundancy;                             // 0x002C(0x0004)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AsyncPhysicsData">();
	}
	static class UAsyncPhysicsData* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAsyncPhysicsData>();
	}
};
static_assert(alignof(UAsyncPhysicsData) == 0x000008, "Wrong alignment on UAsyncPhysicsData");
static_assert(sizeof(UAsyncPhysicsData) == 0x000030, "Wrong size on UAsyncPhysicsData");
static_assert(offsetof(UAsyncPhysicsData, ServerFrame) == 0x000028, "Member 'UAsyncPhysicsData::ServerFrame' has a wrong offset!");
static_assert(offsetof(UAsyncPhysicsData, ReplicationRedundancy) == 0x00002C, "Member 'UAsyncPhysicsData::ReplicationRedundancy' has a wrong offset!");

// Class Engine.SoundNodeDistanceCrossFade
// 0x0010 (0x0058 - 0x0048)
class USoundNodeDistanceCrossFade : public USoundNode
{
public:
	TArray<struct FDistanceDatum>                 CrossFadeInput;                                    // 0x0048(0x0010)(Edit, ExportObject, EditFixedSize, ZeroConstructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"SoundNodeDistanceCrossFade">();
	}
	static class USoundNodeDistanceCrossFade* GetDefaultObj()
	{
		return GetDefaultObjImpl<USoundNodeDistanceCrossFade>();
	}
};
static_assert(alignof(USoundNodeDistanceCrossFade) == 0x000008, "Wrong alignment on USoundNodeDistanceCrossFade");
static_assert(sizeof(USoundNodeDistanceCrossFade) == 0x000058, "Wrong size on USoundNodeDistanceCrossFade");
static_assert(offsetof(USoundNodeDistanceCrossFade, CrossFadeInput) == 0x000048, "Member 'USoundNodeDistanceCrossFade::CrossFadeInput' has a wrong offset!");

// Class Engine.SoundNodeParamCrossFade
// 0x0008 (0x0060 - 0x0058)
class USoundNodeParamCrossFade final : public USoundNodeDistanceCrossFade
{
public:
	class FName                                   ParamName;                                         // 0x0058(0x0008)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"SoundNodeParamCrossFade">();
	}
	static class USoundNodeParamCrossFade* GetDefaultObj()
	{
		return GetDefaultObjImpl<USoundNodeParamCrossFade>();
	}
};
static_assert(alignof(USoundNodeParamCrossFade) == 0x000008, "Wrong alignment on USoundNodeParamCrossFade");
static_assert(sizeof(USoundNodeParamCrossFade) == 0x000060, "Wrong size on USoundNodeParamCrossFade");
static_assert(offsetof(USoundNodeParamCrossFade, ParamName) == 0x000058, "Member 'USoundNodeParamCrossFade::ParamName' has a wrong offset!");

// Class Engine.MaterialExpressionEyeAdaptationInverse
// 0x0050 (0x0100 - 0x00B0)
class UMaterialExpressionEyeAdaptationInverse final : public UMaterialExpression
{
public:
	struct FExpressionInput                       LightValueInput;                                   // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       AlphaInput;                                        // 0x00D8(0x0028)(NoDestructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionEyeAdaptationInverse">();
	}
	static class UMaterialExpressionEyeAdaptationInverse* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionEyeAdaptationInverse>();
	}
};
static_assert(alignof(UMaterialExpressionEyeAdaptationInverse) == 0x000008, "Wrong alignment on UMaterialExpressionEyeAdaptationInverse");
static_assert(sizeof(UMaterialExpressionEyeAdaptationInverse) == 0x000100, "Wrong size on UMaterialExpressionEyeAdaptationInverse");
static_assert(offsetof(UMaterialExpressionEyeAdaptationInverse, LightValueInput) == 0x0000B0, "Member 'UMaterialExpressionEyeAdaptationInverse::LightValueInput' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionEyeAdaptationInverse, AlphaInput) == 0x0000D8, "Member 'UMaterialExpressionEyeAdaptationInverse::AlphaInput' has a wrong offset!");

// Class Engine.AudioPanelWidgetInterface
// 0x0000 (0x0000 - 0x0000)
class IAudioPanelWidgetInterface final
{
public:
	class FText GetEditorName();
	class FName GetIconBrushName();

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AudioPanelWidgetInterface">();
	}
	static class IAudioPanelWidgetInterface* GetDefaultObj()
	{
		return GetDefaultObjImpl<IAudioPanelWidgetInterface>();
	}

	class UObject* AsUObject()
	{
		return reinterpret_cast<UObject*>(this);
	}
	const class UObject* AsUObject() const
	{
		return reinterpret_cast<const UObject*>(this);
	}
};
static_assert(alignof(IAudioPanelWidgetInterface) == 0x000001, "Wrong alignment on IAudioPanelWidgetInterface");
static_assert(sizeof(IAudioPanelWidgetInterface) == 0x000001, "Wrong size on IAudioPanelWidgetInterface");

// Class Engine.SoundNodeQualityLevel
// 0x0008 (0x0050 - 0x0048)
class USoundNodeQualityLevel final : public USoundNode
{
public:
	int32                                         CookedQualityLevelIndex;                           // 0x0048(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_4C[0x4];                                       // 0x004C(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"SoundNodeQualityLevel">();
	}
	static class USoundNodeQualityLevel* GetDefaultObj()
	{
		return GetDefaultObjImpl<USoundNodeQualityLevel>();
	}
};
static_assert(alignof(USoundNodeQualityLevel) == 0x000008, "Wrong alignment on USoundNodeQualityLevel");
static_assert(sizeof(USoundNodeQualityLevel) == 0x000050, "Wrong size on USoundNodeQualityLevel");
static_assert(offsetof(USoundNodeQualityLevel, CookedQualityLevelIndex) == 0x000048, "Member 'USoundNodeQualityLevel::CookedQualityLevelIndex' has a wrong offset!");

// Class Engine.MaterialExpressionStrataHazinessToSecondaryRoughness
// 0x0050 (0x0100 - 0x00B0)
class UMaterialExpressionStrataHazinessToSecondaryRoughness final : public UMaterialExpressionStrataUtilityBase
{
public:
	struct FExpressionInput                       BaseRoughness;                                     // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       Haziness;                                          // 0x00D8(0x0028)(NoDestructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionStrataHazinessToSecondaryRoughness">();
	}
	static class UMaterialExpressionStrataHazinessToSecondaryRoughness* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionStrataHazinessToSecondaryRoughness>();
	}
};
static_assert(alignof(UMaterialExpressionStrataHazinessToSecondaryRoughness) == 0x000008, "Wrong alignment on UMaterialExpressionStrataHazinessToSecondaryRoughness");
static_assert(sizeof(UMaterialExpressionStrataHazinessToSecondaryRoughness) == 0x000100, "Wrong size on UMaterialExpressionStrataHazinessToSecondaryRoughness");
static_assert(offsetof(UMaterialExpressionStrataHazinessToSecondaryRoughness, BaseRoughness) == 0x0000B0, "Member 'UMaterialExpressionStrataHazinessToSecondaryRoughness::BaseRoughness' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionStrataHazinessToSecondaryRoughness, Haziness) == 0x0000D8, "Member 'UMaterialExpressionStrataHazinessToSecondaryRoughness::Haziness' has a wrong offset!");

// Class Engine.AnimStateMachineTypes
// 0x0000 (0x0028 - 0x0028)
class UAnimStateMachineTypes final : public UObject
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AnimStateMachineTypes">();
	}
	static class UAnimStateMachineTypes* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAnimStateMachineTypes>();
	}
};
static_assert(alignof(UAnimStateMachineTypes) == 0x000008, "Wrong alignment on UAnimStateMachineTypes");
static_assert(sizeof(UAnimStateMachineTypes) == 0x000028, "Wrong size on UAnimStateMachineTypes");

// Class Engine.BlendableInterface
// 0x0000 (0x0000 - 0x0000)
class IBlendableInterface final
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"BlendableInterface">();
	}
	static class IBlendableInterface* GetDefaultObj()
	{
		return GetDefaultObjImpl<IBlendableInterface>();
	}

	class UObject* AsUObject()
	{
		return reinterpret_cast<UObject*>(this);
	}
	const class UObject* AsUObject() const
	{
		return reinterpret_cast<const UObject*>(this);
	}
};
static_assert(alignof(IBlendableInterface) == 0x000001, "Wrong alignment on IBlendableInterface");
static_assert(sizeof(IBlendableInterface) == 0x000001, "Wrong size on IBlendableInterface");

// Class Engine.AnalysisProperties
// 0x0010 (0x0038 - 0x0028)
class UAnalysisProperties final : public UObject
{
public:
	class FString                                 Function;                                          // 0x0028(0x0010)(ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AnalysisProperties">();
	}
	static class UAnalysisProperties* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAnalysisProperties>();
	}
};
static_assert(alignof(UAnalysisProperties) == 0x000008, "Wrong alignment on UAnalysisProperties");
static_assert(sizeof(UAnalysisProperties) == 0x000038, "Wrong size on UAnalysisProperties");
static_assert(offsetof(UAnalysisProperties, Function) == 0x000028, "Member 'UAnalysisProperties::Function' has a wrong offset!");

// Class Engine.MaterialExpressionDistanceToNearestSurface
// 0x0028 (0x00D8 - 0x00B0)
class UMaterialExpressionDistanceToNearestSurface final : public UMaterialExpression
{
public:
	struct FExpressionInput                       position;                                          // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionDistanceToNearestSurface">();
	}
	static class UMaterialExpressionDistanceToNearestSurface* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionDistanceToNearestSurface>();
	}
};
static_assert(alignof(UMaterialExpressionDistanceToNearestSurface) == 0x000008, "Wrong alignment on UMaterialExpressionDistanceToNearestSurface");
static_assert(sizeof(UMaterialExpressionDistanceToNearestSurface) == 0x0000D8, "Wrong size on UMaterialExpressionDistanceToNearestSurface");
static_assert(offsetof(UMaterialExpressionDistanceToNearestSurface, position) == 0x0000B0, "Member 'UMaterialExpressionDistanceToNearestSurface::position' has a wrong offset!");

// Class Engine.BlendSpace
// 0x0140 (0x01C0 - 0x0080)
class UBlendSpace : public UAnimationAsset
{
public:
	uint8                                         Pad_80[0x8];                                       // 0x0080(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	bool                                          bContainsRotationOffsetMeshSpaceSamples;           // 0x0088(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_89[0x3];                                       // 0x0089(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	struct FInterpolationParameter                InterpolationParam[0x3];                           // 0x008C(0x0010)(Edit, NoDestructor, NativeAccessSpecifierPublic)
	float                                         TargetWeightInterpolationSpeedPerSec;              // 0x00BC(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bTargetWeightInterpolationEaseInOut;               // 0x00C0(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bAllowMeshSpaceBlending;                           // 0x00C1(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bLoop;                                             // 0x00C2(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_C3[0x1];                                       // 0x00C3(0x0001)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         AnimLength;                                        // 0x00C4(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	ENotifyTriggerMode                            NotifyTriggerMode;                                 // 0x00C8(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bInterpolateUsingGrid;                             // 0x00C9(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EPreferredTriangulationDirection              PreferredTriangulationDirection;                   // 0x00CA(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EBlendSpacePerBoneBlendMode                   PerBoneBlendMode;                                  // 0x00CB(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_CC[0x4];                                       // 0x00CC(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<struct FPerBoneInterpolation>          ManualPerBoneOverrides;                            // 0x00D0(0x0010)(Edit, ZeroConstructor, Protected, NativeAccessSpecifierProtected)
	struct FBlendSpaceBlendProfile                PerBoneBlendProfile;                               // 0x00E0(0x0010)(Edit, NoDestructor, Protected, NativeAccessSpecifierProtected)
	uint8                                         Pad_F0[0x10];                                      // 0x00F0(0x0010)(Fixing Size After Last Property [ Dumper-7 ])
	int32                                         SampleIndexWithMarkers;                            // 0x0100(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_104[0x4];                                      // 0x0104(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<struct FBlendSample>                   SampleData;                                        // 0x0108(0x0010)(Edit, ZeroConstructor, Protected, NativeAccessSpecifierProtected)
	TArray<struct FEditorElement>                 GridSamples;                                       // 0x0118(0x0010)(ZeroConstructor, Protected, NativeAccessSpecifierProtected)
	struct FBlendSpaceData                        BlendSpaceData;                                    // 0x0128(0x0020)(Protected, NativeAccessSpecifierProtected)
	struct FBlendParameter                        BlendParameters[0x3];                              // 0x0148(0x0020)(Edit, Protected, NativeAccessSpecifierProtected)
	EBlendSpaceAxis                               AxisToScaleAnimation;                              // 0x01A8(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_1A9[0x7];                                      // 0x01A9(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<int32>                                 DimensionIndices;                                  // 0x01B0(0x0010)(ZeroConstructor, Protected, NativeAccessSpecifierProtected)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"BlendSpace">();
	}
	static class UBlendSpace* GetDefaultObj()
	{
		return GetDefaultObjImpl<UBlendSpace>();
	}
};
static_assert(alignof(UBlendSpace) == 0x000008, "Wrong alignment on UBlendSpace");
static_assert(sizeof(UBlendSpace) == 0x0001C0, "Wrong size on UBlendSpace");
static_assert(offsetof(UBlendSpace, bContainsRotationOffsetMeshSpaceSamples) == 0x000088, "Member 'UBlendSpace::bContainsRotationOffsetMeshSpaceSamples' has a wrong offset!");
static_assert(offsetof(UBlendSpace, InterpolationParam) == 0x00008C, "Member 'UBlendSpace::InterpolationParam' has a wrong offset!");
static_assert(offsetof(UBlendSpace, TargetWeightInterpolationSpeedPerSec) == 0x0000BC, "Member 'UBlendSpace::TargetWeightInterpolationSpeedPerSec' has a wrong offset!");
static_assert(offsetof(UBlendSpace, bTargetWeightInterpolationEaseInOut) == 0x0000C0, "Member 'UBlendSpace::bTargetWeightInterpolationEaseInOut' has a wrong offset!");
static_assert(offsetof(UBlendSpace, bAllowMeshSpaceBlending) == 0x0000C1, "Member 'UBlendSpace::bAllowMeshSpaceBlending' has a wrong offset!");
static_assert(offsetof(UBlendSpace, bLoop) == 0x0000C2, "Member 'UBlendSpace::bLoop' has a wrong offset!");
static_assert(offsetof(UBlendSpace, AnimLength) == 0x0000C4, "Member 'UBlendSpace::AnimLength' has a wrong offset!");
static_assert(offsetof(UBlendSpace, NotifyTriggerMode) == 0x0000C8, "Member 'UBlendSpace::NotifyTriggerMode' has a wrong offset!");
static_assert(offsetof(UBlendSpace, bInterpolateUsingGrid) == 0x0000C9, "Member 'UBlendSpace::bInterpolateUsingGrid' has a wrong offset!");
static_assert(offsetof(UBlendSpace, PreferredTriangulationDirection) == 0x0000CA, "Member 'UBlendSpace::PreferredTriangulationDirection' has a wrong offset!");
static_assert(offsetof(UBlendSpace, PerBoneBlendMode) == 0x0000CB, "Member 'UBlendSpace::PerBoneBlendMode' has a wrong offset!");
static_assert(offsetof(UBlendSpace, ManualPerBoneOverrides) == 0x0000D0, "Member 'UBlendSpace::ManualPerBoneOverrides' has a wrong offset!");
static_assert(offsetof(UBlendSpace, PerBoneBlendProfile) == 0x0000E0, "Member 'UBlendSpace::PerBoneBlendProfile' has a wrong offset!");
static_assert(offsetof(UBlendSpace, SampleIndexWithMarkers) == 0x000100, "Member 'UBlendSpace::SampleIndexWithMarkers' has a wrong offset!");
static_assert(offsetof(UBlendSpace, SampleData) == 0x000108, "Member 'UBlendSpace::SampleData' has a wrong offset!");
static_assert(offsetof(UBlendSpace, GridSamples) == 0x000118, "Member 'UBlendSpace::GridSamples' has a wrong offset!");
static_assert(offsetof(UBlendSpace, BlendSpaceData) == 0x000128, "Member 'UBlendSpace::BlendSpaceData' has a wrong offset!");
static_assert(offsetof(UBlendSpace, BlendParameters) == 0x000148, "Member 'UBlendSpace::BlendParameters' has a wrong offset!");
static_assert(offsetof(UBlendSpace, AxisToScaleAnimation) == 0x0001A8, "Member 'UBlendSpace::AxisToScaleAnimation' has a wrong offset!");
static_assert(offsetof(UBlendSpace, DimensionIndices) == 0x0001B0, "Member 'UBlendSpace::DimensionIndices' has a wrong offset!");

// Class Engine.AnimNotifyMirrorInspectionLibrary
// 0x0000 (0x0028 - 0x0028)
class UAnimNotifyMirrorInspectionLibrary final : public UBlueprintFunctionLibrary
{
public:
	static const class UMirrorDataTable* GetMirrorDataTable(const struct FAnimNotifyEventReference& EventReference);
	static bool IsTriggeredByMirroredAnimation(const struct FAnimNotifyEventReference& EventReference);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AnimNotifyMirrorInspectionLibrary">();
	}
	static class UAnimNotifyMirrorInspectionLibrary* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAnimNotifyMirrorInspectionLibrary>();
	}
};
static_assert(alignof(UAnimNotifyMirrorInspectionLibrary) == 0x000008, "Wrong alignment on UAnimNotifyMirrorInspectionLibrary");
static_assert(sizeof(UAnimNotifyMirrorInspectionLibrary) == 0x000028, "Wrong size on UAnimNotifyMirrorInspectionLibrary");

// Class Engine.Texture2D
// 0x00B0 (0x0280 - 0x01D0)
#pragma pack(push, 0x1)
class alignas(0x10) UTexture2D : public UTexture
{
public:
	int32                                         FirstResourceMemMip;                               // 0x01C8(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bTemporarilyDisableStreaming : 1;                  // 0x01CC(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Transient, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate))
	ETextureAddress                               AddressX;                                          // 0x01CD(0x0001)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, AssetRegistrySearchable, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	ETextureAddress                               AddressY;                                          // 0x01CE(0x0001)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, AssetRegistrySearchable, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1CF[0x1];                                      // 0x01CF(0x0001)(Fixing Size After Last Property [ Dumper-7 ])
	struct FIntPoint                              ImportedSize;                                      // 0x01D0(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_1D8[0xA0];                                     // 0x01D8(0x00A0)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	int32 Blueprint_GetSizeX() const;
	int32 Blueprint_GetSizeY() const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"Texture2D">();
	}
	static class UTexture2D* GetDefaultObj()
	{
		return GetDefaultObjImpl<UTexture2D>();
	}
};
#pragma pack(pop)
static_assert(alignof(UTexture2D) == 0x000010, "Wrong alignment on UTexture2D");
static_assert(sizeof(UTexture2D) == 0x000280, "Wrong size on UTexture2D");
static_assert(offsetof(UTexture2D, FirstResourceMemMip) == 0x0001C8, "Member 'UTexture2D::FirstResourceMemMip' has a wrong offset!");
static_assert(offsetof(UTexture2D, AddressX) == 0x0001CD, "Member 'UTexture2D::AddressX' has a wrong offset!");
static_assert(offsetof(UTexture2D, AddressY) == 0x0001CE, "Member 'UTexture2D::AddressY' has a wrong offset!");
static_assert(offsetof(UTexture2D, ImportedSize) == 0x0001D0, "Member 'UTexture2D::ImportedSize' has a wrong offset!");

// Class Engine.VirtualTexture2D
// 0x0010 (0x0290 - 0x0280)
class UVirtualTexture2D final : public UTexture2D
{
public:
	struct FVirtualTextureBuildSettings           Settings;                                          // 0x0278(0x0008)(NoDestructor, NativeAccessSpecifierPublic)
	bool                                          bContinuousUpdate;                                 // 0x0280(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bSinglePhysicalSpace;                              // 0x0281(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_282[0xE];                                      // 0x0282(0x000E)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"VirtualTexture2D">();
	}
	static class UVirtualTexture2D* GetDefaultObj()
	{
		return GetDefaultObjImpl<UVirtualTexture2D>();
	}
};
static_assert(alignof(UVirtualTexture2D) == 0x000010, "Wrong alignment on UVirtualTexture2D");
static_assert(sizeof(UVirtualTexture2D) == 0x000290, "Wrong size on UVirtualTexture2D");
static_assert(offsetof(UVirtualTexture2D, Settings) == 0x000278, "Member 'UVirtualTexture2D::Settings' has a wrong offset!");
static_assert(offsetof(UVirtualTexture2D, bContinuousUpdate) == 0x000280, "Member 'UVirtualTexture2D::bContinuousUpdate' has a wrong offset!");
static_assert(offsetof(UVirtualTexture2D, bSinglePhysicalSpace) == 0x000281, "Member 'UVirtualTexture2D::bSinglePhysicalSpace' has a wrong offset!");

// Class Engine.MaterialExpressionParticleRandom
// 0x0000 (0x00B0 - 0x00B0)
class UMaterialExpressionParticleRandom final : public UMaterialExpression
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionParticleRandom">();
	}
	static class UMaterialExpressionParticleRandom* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionParticleRandom>();
	}
};
static_assert(alignof(UMaterialExpressionParticleRandom) == 0x000008, "Wrong alignment on UMaterialExpressionParticleRandom");
static_assert(sizeof(UMaterialExpressionParticleRandom) == 0x0000B0, "Wrong size on UMaterialExpressionParticleRandom");

// Class Engine.Breakpoint
// 0x0000 (0x0028 - 0x0028)
class UBreakpoint final : public UObject
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"Breakpoint">();
	}
	static class UBreakpoint* GetDefaultObj()
	{
		return GetDefaultObjImpl<UBreakpoint>();
	}
};
static_assert(alignof(UBreakpoint) == 0x000008, "Wrong alignment on UBreakpoint");
static_assert(sizeof(UBreakpoint) == 0x000028, "Wrong size on UBreakpoint");

// Class Engine.BlueprintExtension
// 0x0000 (0x0028 - 0x0028)
class UBlueprintExtension final : public UObject
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"BlueprintExtension">();
	}
	static class UBlueprintExtension* GetDefaultObj()
	{
		return GetDefaultObjImpl<UBlueprintExtension>();
	}
};
static_assert(alignof(UBlueprintExtension) == 0x000008, "Wrong alignment on UBlueprintExtension");
static_assert(sizeof(UBlueprintExtension) == 0x000028, "Wrong size on UBlueprintExtension");

// Class Engine.AnimNotify_ResumeClothingSimulation
// 0x0000 (0x0038 - 0x0038)
class UAnimNotify_ResumeClothingSimulation final : public UAnimNotify
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AnimNotify_ResumeClothingSimulation">();
	}
	static class UAnimNotify_ResumeClothingSimulation* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAnimNotify_ResumeClothingSimulation>();
	}
};
static_assert(alignof(UAnimNotify_ResumeClothingSimulation) == 0x000008, "Wrong alignment on UAnimNotify_ResumeClothingSimulation");
static_assert(sizeof(UAnimNotify_ResumeClothingSimulation) == 0x000038, "Wrong size on UAnimNotify_ResumeClothingSimulation");

// Class Engine.MaterialExpressionParameter
// 0x0028 (0x00D8 - 0x00B0)
class UMaterialExpressionParameter : public UMaterialExpression
{
public:
	class FName                                   ParameterName;                                     // 0x00B0(0x0008)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FGuid                                  ExpressionGUID;                                    // 0x00B8(0x0010)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FName                                   Group;                                             // 0x00C8(0x0008)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         SortPriority;                                      // 0x00D0(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_D4[0x4];                                       // 0x00D4(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionParameter">();
	}
	static class UMaterialExpressionParameter* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionParameter>();
	}
};
static_assert(alignof(UMaterialExpressionParameter) == 0x000008, "Wrong alignment on UMaterialExpressionParameter");
static_assert(sizeof(UMaterialExpressionParameter) == 0x0000D8, "Wrong size on UMaterialExpressionParameter");
static_assert(offsetof(UMaterialExpressionParameter, ParameterName) == 0x0000B0, "Member 'UMaterialExpressionParameter::ParameterName' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionParameter, ExpressionGUID) == 0x0000B8, "Member 'UMaterialExpressionParameter::ExpressionGUID' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionParameter, Group) == 0x0000C8, "Member 'UMaterialExpressionParameter::Group' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionParameter, SortPriority) == 0x0000D0, "Member 'UMaterialExpressionParameter::SortPriority' has a wrong offset!");

// Class Engine.MaterialExpressionScalarParameter
// 0x0010 (0x00E8 - 0x00D8)
class UMaterialExpressionScalarParameter : public UMaterialExpressionParameter
{
public:
	float                                         DefaultValue;                                      // 0x00D8(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bUseCustomPrimitiveData;                           // 0x00DC(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         PrimitiveDataIndex;                                // 0x00DD(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_DE[0x2];                                       // 0x00DE(0x0002)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         SliderMin;                                         // 0x00E0(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         SliderMax;                                         // 0x00E4(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionScalarParameter">();
	}
	static class UMaterialExpressionScalarParameter* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionScalarParameter>();
	}
};
static_assert(alignof(UMaterialExpressionScalarParameter) == 0x000008, "Wrong alignment on UMaterialExpressionScalarParameter");
static_assert(sizeof(UMaterialExpressionScalarParameter) == 0x0000E8, "Wrong size on UMaterialExpressionScalarParameter");
static_assert(offsetof(UMaterialExpressionScalarParameter, DefaultValue) == 0x0000D8, "Member 'UMaterialExpressionScalarParameter::DefaultValue' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionScalarParameter, bUseCustomPrimitiveData) == 0x0000DC, "Member 'UMaterialExpressionScalarParameter::bUseCustomPrimitiveData' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionScalarParameter, PrimitiveDataIndex) == 0x0000DD, "Member 'UMaterialExpressionScalarParameter::PrimitiveDataIndex' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionScalarParameter, SliderMin) == 0x0000E0, "Member 'UMaterialExpressionScalarParameter::SliderMin' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionScalarParameter, SliderMax) == 0x0000E4, "Member 'UMaterialExpressionScalarParameter::SliderMax' has a wrong offset!");

// Class Engine.MaterialExpressionCurveAtlasRowParameter
// 0x0038 (0x0120 - 0x00E8)
class UMaterialExpressionCurveAtlasRowParameter final : public UMaterialExpressionScalarParameter
{
public:
	class UCurveLinearColor*                      Curve;                                             // 0x00E8(0x0008)(Edit, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UCurveLinearColorAtlas*                 Atlas;                                             // 0x00F0(0x0008)(Edit, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FExpressionInput                       InputTime;                                         // 0x00F8(0x0028)(NoDestructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionCurveAtlasRowParameter">();
	}
	static class UMaterialExpressionCurveAtlasRowParameter* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionCurveAtlasRowParameter>();
	}
};
static_assert(alignof(UMaterialExpressionCurveAtlasRowParameter) == 0x000008, "Wrong alignment on UMaterialExpressionCurveAtlasRowParameter");
static_assert(sizeof(UMaterialExpressionCurveAtlasRowParameter) == 0x000120, "Wrong size on UMaterialExpressionCurveAtlasRowParameter");
static_assert(offsetof(UMaterialExpressionCurveAtlasRowParameter, Curve) == 0x0000E8, "Member 'UMaterialExpressionCurveAtlasRowParameter::Curve' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionCurveAtlasRowParameter, Atlas) == 0x0000F0, "Member 'UMaterialExpressionCurveAtlasRowParameter::Atlas' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionCurveAtlasRowParameter, InputTime) == 0x0000F8, "Member 'UMaterialExpressionCurveAtlasRowParameter::InputTime' has a wrong offset!");

// Class Engine.BookmarkBase
// 0x0000 (0x0028 - 0x0028)
class UBookmarkBase : public UObject
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"BookmarkBase">();
	}
	static class UBookmarkBase* GetDefaultObj()
	{
		return GetDefaultObjImpl<UBookmarkBase>();
	}
};
static_assert(alignof(UBookmarkBase) == 0x000008, "Wrong alignment on UBookmarkBase");
static_assert(sizeof(UBookmarkBase) == 0x000028, "Wrong size on UBookmarkBase");

// Class Engine.PoseAsset
// 0x0090 (0x0110 - 0x0080)
class UPoseAsset final : public UAnimationAsset
{
public:
	struct FPoseDataContainer                     PoseContainer;                                     // 0x0080(0x0070)(NativeAccessSpecifierPrivate)
	bool                                          bAdditivePose;                                     // 0x00F0(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_F1[0x3];                                       // 0x00F1(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	int32                                         BasePoseIndex;                                     // 0x00F4(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	class FName                                   RetargetSource;                                    // 0x00F8(0x0008)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TArray<struct FTransform>                     RetargetSourceAssetReferencePose;                  // 0x0100(0x0010)(ZeroConstructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"PoseAsset">();
	}
	static class UPoseAsset* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPoseAsset>();
	}
};
static_assert(alignof(UPoseAsset) == 0x000008, "Wrong alignment on UPoseAsset");
static_assert(sizeof(UPoseAsset) == 0x000110, "Wrong size on UPoseAsset");
static_assert(offsetof(UPoseAsset, PoseContainer) == 0x000080, "Member 'UPoseAsset::PoseContainer' has a wrong offset!");
static_assert(offsetof(UPoseAsset, bAdditivePose) == 0x0000F0, "Member 'UPoseAsset::bAdditivePose' has a wrong offset!");
static_assert(offsetof(UPoseAsset, BasePoseIndex) == 0x0000F4, "Member 'UPoseAsset::BasePoseIndex' has a wrong offset!");
static_assert(offsetof(UPoseAsset, RetargetSource) == 0x0000F8, "Member 'UPoseAsset::RetargetSource' has a wrong offset!");
static_assert(offsetof(UPoseAsset, RetargetSourceAssetReferencePose) == 0x000100, "Member 'UPoseAsset::RetargetSourceAssetReferencePose' has a wrong offset!");

// Class Engine.BookMark2D
// 0x0010 (0x0038 - 0x0028)
class UBookMark2D final : public UBookmarkBase
{
public:
	float                                         Zoom2D;                                            // 0x0028(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FIntPoint                              Location;                                          // 0x002C(0x0008)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_34[0x4];                                       // 0x0034(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"BookMark2D">();
	}
	static class UBookMark2D* GetDefaultObj()
	{
		return GetDefaultObjImpl<UBookMark2D>();
	}
};
static_assert(alignof(UBookMark2D) == 0x000008, "Wrong alignment on UBookMark2D");
static_assert(sizeof(UBookMark2D) == 0x000038, "Wrong size on UBookMark2D");
static_assert(offsetof(UBookMark2D, Zoom2D) == 0x000028, "Member 'UBookMark2D::Zoom2D' has a wrong offset!");
static_assert(offsetof(UBookMark2D, Location) == 0x00002C, "Member 'UBookMark2D::Location' has a wrong offset!");

// Class Engine.MaterialExpressionBinaryOp
// 0x0058 (0x0108 - 0x00B0)
class UMaterialExpressionBinaryOp : public UMaterialExpression
{
public:
	struct FExpressionInput                       A;                                                 // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       B;                                                 // 0x00D8(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	float                                         ConstA;                                            // 0x0100(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         ConstB;                                            // 0x0104(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionBinaryOp">();
	}
	static class UMaterialExpressionBinaryOp* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionBinaryOp>();
	}
};
static_assert(alignof(UMaterialExpressionBinaryOp) == 0x000008, "Wrong alignment on UMaterialExpressionBinaryOp");
static_assert(sizeof(UMaterialExpressionBinaryOp) == 0x000108, "Wrong size on UMaterialExpressionBinaryOp");
static_assert(offsetof(UMaterialExpressionBinaryOp, A) == 0x0000B0, "Member 'UMaterialExpressionBinaryOp::A' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionBinaryOp, B) == 0x0000D8, "Member 'UMaterialExpressionBinaryOp::B' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionBinaryOp, ConstA) == 0x000100, "Member 'UMaterialExpressionBinaryOp::ConstA' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionBinaryOp, ConstB) == 0x000104, "Member 'UMaterialExpressionBinaryOp::ConstB' has a wrong offset!");

// Class Engine.MaterialExpressionLess
// 0x0000 (0x0108 - 0x0108)
class UMaterialExpressionLess final : public UMaterialExpressionBinaryOp
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionLess">();
	}
	static class UMaterialExpressionLess* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionLess>();
	}
};
static_assert(alignof(UMaterialExpressionLess) == 0x000008, "Wrong alignment on UMaterialExpressionLess");
static_assert(sizeof(UMaterialExpressionLess) == 0x000108, "Wrong size on UMaterialExpressionLess");

// Class Engine.ReflectionCapture
// 0x0008 (0x02A8 - 0x02A0)
class AReflectionCapture : public AActor
{
public:
	class UReflectionCaptureComponent*            CaptureComponent;                                  // 0x02A0(0x0008)(Edit, BlueprintVisible, ExportObject, BlueprintReadOnly, ZeroConstructor, EditConst, InstancedReference, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ReflectionCapture">();
	}
	static class AReflectionCapture* GetDefaultObj()
	{
		return GetDefaultObjImpl<AReflectionCapture>();
	}
};
static_assert(alignof(AReflectionCapture) == 0x000008, "Wrong alignment on AReflectionCapture");
static_assert(sizeof(AReflectionCapture) == 0x0002A8, "Wrong size on AReflectionCapture");
static_assert(offsetof(AReflectionCapture, CaptureComponent) == 0x0002A0, "Member 'AReflectionCapture::CaptureComponent' has a wrong offset!");

// Class Engine.AnimationCurveIdentifierExtensions
// 0x0000 (0x0028 - 0x0028)
class UAnimationCurveIdentifierExtensions final : public UBlueprintFunctionLibrary
{
public:
	static class FName GetName(struct FAnimationCurveIdentifier& Identifier);
	static ERawCurveTrackTypes GetType(struct FAnimationCurveIdentifier& Identifier);
	static bool IsValid(struct FAnimationCurveIdentifier& Identifier);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AnimationCurveIdentifierExtensions">();
	}
	static class UAnimationCurveIdentifierExtensions* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAnimationCurveIdentifierExtensions>();
	}
};
static_assert(alignof(UAnimationCurveIdentifierExtensions) == 0x000008, "Wrong alignment on UAnimationCurveIdentifierExtensions");
static_assert(sizeof(UAnimationCurveIdentifierExtensions) == 0x000028, "Wrong size on UAnimationCurveIdentifierExtensions");

// Class Engine.BoxReflectionCapture
// 0x0000 (0x02A8 - 0x02A8)
class ABoxReflectionCapture final : public AReflectionCapture
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"BoxReflectionCapture">();
	}
	static class ABoxReflectionCapture* GetDefaultObj()
	{
		return GetDefaultObjImpl<ABoxReflectionCapture>();
	}
};
static_assert(alignof(ABoxReflectionCapture) == 0x000008, "Wrong alignment on ABoxReflectionCapture");
static_assert(sizeof(ABoxReflectionCapture) == 0x0002A8, "Wrong size on ABoxReflectionCapture");

// Class Engine.BoxReflectionCaptureComponent
// 0x0020 (0x0330 - 0x0310)
class UBoxReflectionCaptureComponent final : public UReflectionCaptureComponent
{
public:
	float                                         BoxTransitionDistance;                             // 0x0310(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_314[0x4];                                      // 0x0314(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	class UBoxComponent*                          PreviewInfluenceBox;                               // 0x0318(0x0008)(ExportObject, ZeroConstructor, InstancedReference, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UBoxComponent*                          PreviewCaptureBox;                                 // 0x0320(0x0008)(ExportObject, ZeroConstructor, InstancedReference, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_328[0x8];                                      // 0x0328(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"BoxReflectionCaptureComponent">();
	}
	static class UBoxReflectionCaptureComponent* GetDefaultObj()
	{
		return GetDefaultObjImpl<UBoxReflectionCaptureComponent>();
	}
};
static_assert(alignof(UBoxReflectionCaptureComponent) == 0x000010, "Wrong alignment on UBoxReflectionCaptureComponent");
static_assert(sizeof(UBoxReflectionCaptureComponent) == 0x000330, "Wrong size on UBoxReflectionCaptureComponent");
static_assert(offsetof(UBoxReflectionCaptureComponent, BoxTransitionDistance) == 0x000310, "Member 'UBoxReflectionCaptureComponent::BoxTransitionDistance' has a wrong offset!");
static_assert(offsetof(UBoxReflectionCaptureComponent, PreviewInfluenceBox) == 0x000318, "Member 'UBoxReflectionCaptureComponent::PreviewInfluenceBox' has a wrong offset!");
static_assert(offsetof(UBoxReflectionCaptureComponent, PreviewCaptureBox) == 0x000320, "Member 'UBoxReflectionCaptureComponent::PreviewCaptureBox' has a wrong offset!");

// Class Engine.AnimNotify_ResetClothingSimulation
// 0x0000 (0x0038 - 0x0038)
class UAnimNotify_ResetClothingSimulation final : public UAnimNotify
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AnimNotify_ResetClothingSimulation">();
	}
	static class UAnimNotify_ResetClothingSimulation* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAnimNotify_ResetClothingSimulation>();
	}
};
static_assert(alignof(UAnimNotify_ResetClothingSimulation) == 0x000008, "Wrong alignment on UAnimNotify_ResetClothingSimulation");
static_assert(sizeof(UAnimNotify_ResetClothingSimulation) == 0x000038, "Wrong size on UAnimNotify_ResetClothingSimulation");

// Class Engine.ContentBundleUnsavedActorMonitor
// 0x0000 (0x0028 - 0x0028)
class UContentBundleUnsavedActorMonitor final : public UObject
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ContentBundleUnsavedActorMonitor">();
	}
	static class UContentBundleUnsavedActorMonitor* GetDefaultObj()
	{
		return GetDefaultObjImpl<UContentBundleUnsavedActorMonitor>();
	}
};
static_assert(alignof(UContentBundleUnsavedActorMonitor) == 0x000008, "Wrong alignment on UContentBundleUnsavedActorMonitor");
static_assert(sizeof(UContentBundleUnsavedActorMonitor) == 0x000028, "Wrong size on UContentBundleUnsavedActorMonitor");

// Class Engine.MaterialExpressionPathTracingQualitySwitch
// 0x0050 (0x0100 - 0x00B0)
class UMaterialExpressionPathTracingQualitySwitch final : public UMaterialExpression
{
public:
	struct FExpressionInput                       Normal;                                            // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       PathTraced;                                        // 0x00D8(0x0028)(NoDestructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionPathTracingQualitySwitch">();
	}
	static class UMaterialExpressionPathTracingQualitySwitch* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionPathTracingQualitySwitch>();
	}
};
static_assert(alignof(UMaterialExpressionPathTracingQualitySwitch) == 0x000008, "Wrong alignment on UMaterialExpressionPathTracingQualitySwitch");
static_assert(sizeof(UMaterialExpressionPathTracingQualitySwitch) == 0x000100, "Wrong size on UMaterialExpressionPathTracingQualitySwitch");
static_assert(offsetof(UMaterialExpressionPathTracingQualitySwitch, Normal) == 0x0000B0, "Member 'UMaterialExpressionPathTracingQualitySwitch::Normal' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionPathTracingQualitySwitch, PathTraced) == 0x0000D8, "Member 'UMaterialExpressionPathTracingQualitySwitch::PathTraced' has a wrong offset!");

// Class Engine.BuiltInAttributesExtensions
// 0x0000 (0x0028 - 0x0028)
class UBuiltInAttributesExtensions final : public UBlueprintFunctionLibrary
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"BuiltInAttributesExtensions">();
	}
	static class UBuiltInAttributesExtensions* GetDefaultObj()
	{
		return GetDefaultObjImpl<UBuiltInAttributesExtensions>();
	}
};
static_assert(alignof(UBuiltInAttributesExtensions) == 0x000008, "Wrong alignment on UBuiltInAttributesExtensions");
static_assert(sizeof(UBuiltInAttributesExtensions) == 0x000028, "Wrong size on UBuiltInAttributesExtensions");

// Class Engine.ChaosBlueprintLibrary
// 0x0000 (0x0028 - 0x0028)
class UChaosBlueprintLibrary final : public UBlueprintFunctionLibrary
{
public:
	static const class UChaosEventRelay* GetEventRelayFromContext(class UObject* ContextObject);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ChaosBlueprintLibrary">();
	}
	static class UChaosBlueprintLibrary* GetDefaultObj()
	{
		return GetDefaultObjImpl<UChaosBlueprintLibrary>();
	}
};
static_assert(alignof(UChaosBlueprintLibrary) == 0x000008, "Wrong alignment on UChaosBlueprintLibrary");
static_assert(sizeof(UChaosBlueprintLibrary) == 0x000028, "Wrong size on UChaosBlueprintLibrary");

// Class Engine.ArrowComponent
// 0x0020 (0x0590 - 0x0570)
class UArrowComponent final : public UPrimitiveComponent
{
public:
	struct FColor                                 ArrowColor;                                        // 0x0570(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         ArrowSize;                                         // 0x0574(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         ArrowLength;                                       // 0x0578(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         ScreenSize;                                        // 0x057C(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bIsScreenSizeScaled : 1;                           // 0x0580(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bTreatAsASprite : 1;                               // 0x0580(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_581[0xF];                                      // 0x0581(0x000F)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void SetArrowColor(const struct FLinearColor& NewColor);
	void SetArrowFColor(const struct FColor& NewColor);
	void SetArrowLength(float NewLength);
	void SetArrowSize(float NewSize);
	void SetIsScreenSizeScaled(bool bNewValue);
	void SetScreenSize(float NewScreenSize);
	void SetTreatAsASprite(bool bNewValue);
	void SetUseInEditorScaling(bool bNewValue);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ArrowComponent">();
	}
	static class UArrowComponent* GetDefaultObj()
	{
		return GetDefaultObjImpl<UArrowComponent>();
	}
};
static_assert(alignof(UArrowComponent) == 0x000010, "Wrong alignment on UArrowComponent");
static_assert(sizeof(UArrowComponent) == 0x000590, "Wrong size on UArrowComponent");
static_assert(offsetof(UArrowComponent, ArrowColor) == 0x000570, "Member 'UArrowComponent::ArrowColor' has a wrong offset!");
static_assert(offsetof(UArrowComponent, ArrowSize) == 0x000574, "Member 'UArrowComponent::ArrowSize' has a wrong offset!");
static_assert(offsetof(UArrowComponent, ArrowLength) == 0x000578, "Member 'UArrowComponent::ArrowLength' has a wrong offset!");
static_assert(offsetof(UArrowComponent, ScreenSize) == 0x00057C, "Member 'UArrowComponent::ScreenSize' has a wrong offset!");

// Class Engine.MaterialExpressionNamedRerouteBase
// 0x0000 (0x00B0 - 0x00B0)
class UMaterialExpressionNamedRerouteBase : public UMaterialExpressionRerouteBase
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionNamedRerouteBase">();
	}
	static class UMaterialExpressionNamedRerouteBase* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionNamedRerouteBase>();
	}
};
static_assert(alignof(UMaterialExpressionNamedRerouteBase) == 0x000008, "Wrong alignment on UMaterialExpressionNamedRerouteBase");
static_assert(sizeof(UMaterialExpressionNamedRerouteBase) == 0x0000B0, "Wrong size on UMaterialExpressionNamedRerouteBase");

// Class Engine.MaterialExpressionNamedRerouteDeclaration
// 0x0050 (0x0100 - 0x00B0)
class UMaterialExpressionNamedRerouteDeclaration final : public UMaterialExpressionNamedRerouteBase
{
public:
	struct FExpressionInput                       Input;                                             // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	class FName                                   Name_0;                                            // 0x00D8(0x0008)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FLinearColor                           NodeColor;                                         // 0x00E0(0x0010)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FGuid                                  VariableGuid;                                      // 0x00F0(0x0010)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionNamedRerouteDeclaration">();
	}
	static class UMaterialExpressionNamedRerouteDeclaration* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionNamedRerouteDeclaration>();
	}
};
static_assert(alignof(UMaterialExpressionNamedRerouteDeclaration) == 0x000008, "Wrong alignment on UMaterialExpressionNamedRerouteDeclaration");
static_assert(sizeof(UMaterialExpressionNamedRerouteDeclaration) == 0x000100, "Wrong size on UMaterialExpressionNamedRerouteDeclaration");
static_assert(offsetof(UMaterialExpressionNamedRerouteDeclaration, Input) == 0x0000B0, "Member 'UMaterialExpressionNamedRerouteDeclaration::Input' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionNamedRerouteDeclaration, Name_0) == 0x0000D8, "Member 'UMaterialExpressionNamedRerouteDeclaration::Name_0' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionNamedRerouteDeclaration, NodeColor) == 0x0000E0, "Member 'UMaterialExpressionNamedRerouteDeclaration::NodeColor' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionNamedRerouteDeclaration, VariableGuid) == 0x0000F0, "Member 'UMaterialExpressionNamedRerouteDeclaration::VariableGuid' has a wrong offset!");

// Class Engine.ChaosEventRelay
// 0x0040 (0x0068 - 0x0028)
class UChaosEventRelay final : public UObject
{
public:
	TMulticastInlineDelegate<void(const TArray<struct FCollisionChaosEvent>& CollisionEvents)> OnCollisionEvent; // 0x0028(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	TMulticastInlineDelegate<void(const TArray<struct FChaosBreakEvent>& BreakEvents)> OnBreakEvent; // 0x0038(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	TMulticastInlineDelegate<void(const TArray<struct FChaosRemovalEvent>& RemovalEvents)> OnRemovalEvent; // 0x0048(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	TMulticastInlineDelegate<void(const TArray<struct FChaosCrumblingEvent>& CrumblingEvents)> OnCrumblingEvent; // 0x0058(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ChaosEventRelay">();
	}
	static class UChaosEventRelay* GetDefaultObj()
	{
		return GetDefaultObjImpl<UChaosEventRelay>();
	}
};
static_assert(alignof(UChaosEventRelay) == 0x000008, "Wrong alignment on UChaosEventRelay");
static_assert(sizeof(UChaosEventRelay) == 0x000068, "Wrong size on UChaosEventRelay");
static_assert(offsetof(UChaosEventRelay, OnCollisionEvent) == 0x000028, "Member 'UChaosEventRelay::OnCollisionEvent' has a wrong offset!");
static_assert(offsetof(UChaosEventRelay, OnBreakEvent) == 0x000038, "Member 'UChaosEventRelay::OnBreakEvent' has a wrong offset!");
static_assert(offsetof(UChaosEventRelay, OnRemovalEvent) == 0x000048, "Member 'UChaosEventRelay::OnRemovalEvent' has a wrong offset!");
static_assert(offsetof(UChaosEventRelay, OnCrumblingEvent) == 0x000058, "Member 'UChaosEventRelay::OnCrumblingEvent' has a wrong offset!");

// Class Engine.AsyncActionLoadPrimaryAssetBase
// 0x0048 (0x0078 - 0x0030)
class UAsyncActionLoadPrimaryAssetBase : public UBlueprintAsyncActionBase
{
public:
	uint8                                         Pad_30[0x48];                                      // 0x0030(0x0048)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AsyncActionLoadPrimaryAssetBase">();
	}
	static class UAsyncActionLoadPrimaryAssetBase* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAsyncActionLoadPrimaryAssetBase>();
	}
};
static_assert(alignof(UAsyncActionLoadPrimaryAssetBase) == 0x000008, "Wrong alignment on UAsyncActionLoadPrimaryAssetBase");
static_assert(sizeof(UAsyncActionLoadPrimaryAssetBase) == 0x000078, "Wrong size on UAsyncActionLoadPrimaryAssetBase");

// Class Engine.Player
// 0x0020 (0x0048 - 0x0028)
class UPlayer : public UObject
{
public:
	uint8                                         Pad_28[0x8];                                       // 0x0028(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	class APlayerController*                      PlayerController;                                  // 0x0030(0x0008)(ZeroConstructor, Transient, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         CurrentNetSpeed;                                   // 0x0038(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         ConfiguredInternetSpeed;                           // 0x003C(0x0004)(ZeroConstructor, Config, GlobalConfig, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         ConfiguredLanSpeed;                                // 0x0040(0x0004)(ZeroConstructor, Config, GlobalConfig, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_44[0x4];                                       // 0x0044(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"Player">();
	}
	static class UPlayer* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPlayer>();
	}
};
static_assert(alignof(UPlayer) == 0x000008, "Wrong alignment on UPlayer");
static_assert(sizeof(UPlayer) == 0x000048, "Wrong size on UPlayer");
static_assert(offsetof(UPlayer, PlayerController) == 0x000030, "Member 'UPlayer::PlayerController' has a wrong offset!");
static_assert(offsetof(UPlayer, CurrentNetSpeed) == 0x000038, "Member 'UPlayer::CurrentNetSpeed' has a wrong offset!");
static_assert(offsetof(UPlayer, ConfiguredInternetSpeed) == 0x00003C, "Member 'UPlayer::ConfiguredInternetSpeed' has a wrong offset!");
static_assert(offsetof(UPlayer, ConfiguredLanSpeed) == 0x000040, "Member 'UPlayer::ConfiguredLanSpeed' has a wrong offset!");

// Class Engine.SplineMeshActor
// 0x0008 (0x02A8 - 0x02A0)
class ASplineMeshActor final : public AActor
{
public:
	class USplineMeshComponent*                   SplineMeshComponent;                               // 0x02A0(0x0008)(Edit, BlueprintVisible, ExportObject, BlueprintReadOnly, ZeroConstructor, EditConst, InstancedReference, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"SplineMeshActor">();
	}
	static class ASplineMeshActor* GetDefaultObj()
	{
		return GetDefaultObjImpl<ASplineMeshActor>();
	}
};
static_assert(alignof(ASplineMeshActor) == 0x000008, "Wrong alignment on ASplineMeshActor");
static_assert(sizeof(ASplineMeshActor) == 0x0002A8, "Wrong size on ASplineMeshActor");
static_assert(offsetof(ASplineMeshActor, SplineMeshComponent) == 0x0002A0, "Member 'ASplineMeshActor::SplineMeshComponent' has a wrong offset!");

// Class Engine.NetConnection
// 0x1DB0 (0x1DF8 - 0x0048)
class UNetConnection : public UPlayer
{
public:
	TArray<class UChildConnection*>               Children;                                          // 0x0048(0x0010)(ZeroConstructor, Transient, UObjectWrapper, NativeAccessSpecifierPublic)
	class UNetDriver*                             Driver;                                            // 0x0058(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TSubclassOf<class UPackageMap>                PackageMapClass;                                   // 0x0060(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UPackageMap*                            PackageMap;                                        // 0x0068(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TArray<class UChannel*>                       OpenChannels;                                      // 0x0070(0x0010)(ZeroConstructor, UObjectWrapper, NativeAccessSpecifierPublic)
	TArray<class AActor*>                         SentTemporaries;                                   // 0x0080(0x0010)(ZeroConstructor, UObjectWrapper, NativeAccessSpecifierPublic)
	class AActor*                                 ViewTarget;                                        // 0x0090(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 OwningActor;                                       // 0x0098(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         MaxPacket;                                         // 0x00A0(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         InternalAck : 1;                                   // 0x00A4(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate))
	uint8                                         Pad_A5[0xBB];                                      // 0x00A5(0x00BB)(Fixing Size After Last Property [ Dumper-7 ])
	struct FUniqueNetIdRepl                       PlayerId;                                          // 0x0160(0x0030)(HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_190[0x48];                                     // 0x0190(0x0048)(Fixing Size After Last Property [ Dumper-7 ])
	double                                        LastReceiveTime;                                   // 0x01D8(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1E0[0x11D0];                                   // 0x01E0(0x11D0)(Fixing Size After Last Property [ Dumper-7 ])
	int32                                         DefaultMaxChannelSize;                             // 0x13B0(0x0004)(ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_13B4[0x334];                                   // 0x13B4(0x0334)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<class UChannel*>                       ChannelsToTick;                                    // 0x16E8(0x0010)(ZeroConstructor, UObjectWrapper, NativeAccessSpecifierPrivate)
	uint8                                         Pad_16F8[0x700];                                   // 0x16F8(0x0700)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"NetConnection">();
	}
	static class UNetConnection* GetDefaultObj()
	{
		return GetDefaultObjImpl<UNetConnection>();
	}
};
static_assert(alignof(UNetConnection) == 0x000008, "Wrong alignment on UNetConnection");
static_assert(sizeof(UNetConnection) == 0x001DF8, "Wrong size on UNetConnection");
static_assert(offsetof(UNetConnection, Children) == 0x000048, "Member 'UNetConnection::Children' has a wrong offset!");
static_assert(offsetof(UNetConnection, Driver) == 0x000058, "Member 'UNetConnection::Driver' has a wrong offset!");
static_assert(offsetof(UNetConnection, PackageMapClass) == 0x000060, "Member 'UNetConnection::PackageMapClass' has a wrong offset!");
static_assert(offsetof(UNetConnection, PackageMap) == 0x000068, "Member 'UNetConnection::PackageMap' has a wrong offset!");
static_assert(offsetof(UNetConnection, OpenChannels) == 0x000070, "Member 'UNetConnection::OpenChannels' has a wrong offset!");
static_assert(offsetof(UNetConnection, SentTemporaries) == 0x000080, "Member 'UNetConnection::SentTemporaries' has a wrong offset!");
static_assert(offsetof(UNetConnection, ViewTarget) == 0x000090, "Member 'UNetConnection::ViewTarget' has a wrong offset!");
static_assert(offsetof(UNetConnection, OwningActor) == 0x000098, "Member 'UNetConnection::OwningActor' has a wrong offset!");
static_assert(offsetof(UNetConnection, MaxPacket) == 0x0000A0, "Member 'UNetConnection::MaxPacket' has a wrong offset!");
static_assert(offsetof(UNetConnection, PlayerId) == 0x000160, "Member 'UNetConnection::PlayerId' has a wrong offset!");
static_assert(offsetof(UNetConnection, LastReceiveTime) == 0x0001D8, "Member 'UNetConnection::LastReceiveTime' has a wrong offset!");
static_assert(offsetof(UNetConnection, DefaultMaxChannelSize) == 0x0013B0, "Member 'UNetConnection::DefaultMaxChannelSize' has a wrong offset!");
static_assert(offsetof(UNetConnection, ChannelsToTick) == 0x0016E8, "Member 'UNetConnection::ChannelsToTick' has a wrong offset!");

// Class Engine.ChildConnection
// 0x0008 (0x1E00 - 0x1DF8)
class UChildConnection final : public UNetConnection
{
public:
	class UNetConnection*                         Parent;                                            // 0x1DF8(0x0008)(ZeroConstructor, Transient, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ChildConnection">();
	}
	static class UChildConnection* GetDefaultObj()
	{
		return GetDefaultObjImpl<UChildConnection>();
	}
};
static_assert(alignof(UChildConnection) == 0x000008, "Wrong alignment on UChildConnection");
static_assert(sizeof(UChildConnection) == 0x001E00, "Wrong size on UChildConnection");
static_assert(offsetof(UChildConnection, Parent) == 0x001DF8, "Member 'UChildConnection::Parent' has a wrong offset!");

// Class Engine.MaterialExpressionForLoop
// 0x0088 (0x0138 - 0x00B0)
class UMaterialExpressionForLoop final : public UMaterialExpression
{
public:
	struct FExpressionExecOutput                  LoopBody;                                          // 0x00B0(0x0008)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionExecOutput                  Completed;                                         // 0x00B8(0x0008)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       StartIndex;                                        // 0x00C0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       EndIndex;                                          // 0x00E8(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       IndexStep;                                         // 0x0110(0x0028)(NoDestructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionForLoop">();
	}
	static class UMaterialExpressionForLoop* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionForLoop>();
	}
};
static_assert(alignof(UMaterialExpressionForLoop) == 0x000008, "Wrong alignment on UMaterialExpressionForLoop");
static_assert(sizeof(UMaterialExpressionForLoop) == 0x000138, "Wrong size on UMaterialExpressionForLoop");
static_assert(offsetof(UMaterialExpressionForLoop, LoopBody) == 0x0000B0, "Member 'UMaterialExpressionForLoop::LoopBody' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionForLoop, Completed) == 0x0000B8, "Member 'UMaterialExpressionForLoop::Completed' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionForLoop, StartIndex) == 0x0000C0, "Member 'UMaterialExpressionForLoop::StartIndex' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionForLoop, EndIndex) == 0x0000E8, "Member 'UMaterialExpressionForLoop::EndIndex' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionForLoop, IndexStep) == 0x000110, "Member 'UMaterialExpressionForLoop::IndexStep' has a wrong offset!");

// Class Engine.CloudStorageBase
// 0x0018 (0x0050 - 0x0038)
class UCloudStorageBase final : public UPlatformInterfaceBase
{
public:
	TArray<class FString>                         LocalCloudFiles;                                   // 0x0038(0x0010)(ZeroConstructor, NativeAccessSpecifierPublic)
	uint8                                         bSuppressDelegateCalls : 1;                        // 0x0048(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_49[0x7];                                       // 0x0049(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"CloudStorageBase">();
	}
	static class UCloudStorageBase* GetDefaultObj()
	{
		return GetDefaultObjImpl<UCloudStorageBase>();
	}
};
static_assert(alignof(UCloudStorageBase) == 0x000008, "Wrong alignment on UCloudStorageBase");
static_assert(sizeof(UCloudStorageBase) == 0x000050, "Wrong size on UCloudStorageBase");
static_assert(offsetof(UCloudStorageBase, LocalCloudFiles) == 0x000038, "Member 'UCloudStorageBase::LocalCloudFiles' has a wrong offset!");

// Class Engine.ComponentDelegateBinding
// 0x0010 (0x0038 - 0x0028)
class UComponentDelegateBinding final : public UDynamicBlueprintBinding
{
public:
	TArray<struct FBlueprintComponentDelegateBinding> ComponentDelegateBindings;                     // 0x0028(0x0010)(ZeroConstructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ComponentDelegateBinding">();
	}
	static class UComponentDelegateBinding* GetDefaultObj()
	{
		return GetDefaultObjImpl<UComponentDelegateBinding>();
	}
};
static_assert(alignof(UComponentDelegateBinding) == 0x000008, "Wrong alignment on UComponentDelegateBinding");
static_assert(sizeof(UComponentDelegateBinding) == 0x000038, "Wrong size on UComponentDelegateBinding");
static_assert(offsetof(UComponentDelegateBinding, ComponentDelegateBindings) == 0x000028, "Member 'UComponentDelegateBinding::ComponentDelegateBindings' has a wrong offset!");

// Class Engine.DataLayerInstance
// 0x0020 (0x0048 - 0x0028)
class UDataLayerInstance : public UObject
{
public:
	EDataLayerRuntimeState                        InitialRuntimeState;                               // 0x0028(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_29[0x7];                                       // 0x0029(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	class UDataLayerInstance*                     Parent;                                            // 0x0030(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	TArray<class UDataLayerInstance*>             Children;                                          // 0x0038(0x0010)(ZeroConstructor, Transient, UObjectWrapper, NativeAccessSpecifierPrivate)

public:
	struct FColor GetDebugColor() const;
	EDataLayerRuntimeState GetInitialRuntimeState() const;
	EDataLayerType GetType() const;
	bool IsEffectiveVisible() const;
	bool IsInitiallyVisible() const;
	bool IsRuntime() const;
	bool IsVisible() const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"DataLayerInstance">();
	}
	static class UDataLayerInstance* GetDefaultObj()
	{
		return GetDefaultObjImpl<UDataLayerInstance>();
	}
};
static_assert(alignof(UDataLayerInstance) == 0x000008, "Wrong alignment on UDataLayerInstance");
static_assert(sizeof(UDataLayerInstance) == 0x000048, "Wrong size on UDataLayerInstance");
static_assert(offsetof(UDataLayerInstance, InitialRuntimeState) == 0x000028, "Member 'UDataLayerInstance::InitialRuntimeState' has a wrong offset!");
static_assert(offsetof(UDataLayerInstance, Parent) == 0x000030, "Member 'UDataLayerInstance::Parent' has a wrong offset!");
static_assert(offsetof(UDataLayerInstance, Children) == 0x000038, "Member 'UDataLayerInstance::Children' has a wrong offset!");

// Class Engine.DataLayerInstancePrivate
// 0x0018 (0x0060 - 0x0048)
class UDataLayerInstancePrivate final : public UDataLayerInstance
{
public:
	class FString                                 ShortName;                                         // 0x0048(0x0010)(ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	class UDataLayerAsset*                        DataLayerAsset;                                    // 0x0058(0x0008)(Edit, ExportObject, ZeroConstructor, EditConst, InstancedReference, NoDestructor, PersistentInstance, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"DataLayerInstancePrivate">();
	}
	static class UDataLayerInstancePrivate* GetDefaultObj()
	{
		return GetDefaultObjImpl<UDataLayerInstancePrivate>();
	}
};
static_assert(alignof(UDataLayerInstancePrivate) == 0x000008, "Wrong alignment on UDataLayerInstancePrivate");
static_assert(sizeof(UDataLayerInstancePrivate) == 0x000060, "Wrong size on UDataLayerInstancePrivate");
static_assert(offsetof(UDataLayerInstancePrivate, ShortName) == 0x000048, "Member 'UDataLayerInstancePrivate::ShortName' has a wrong offset!");
static_assert(offsetof(UDataLayerInstancePrivate, DataLayerAsset) == 0x000058, "Member 'UDataLayerInstancePrivate::DataLayerAsset' has a wrong offset!");

// Class Engine.MaterialExpressionGenericConstant
// 0x0000 (0x00B0 - 0x00B0)
class UMaterialExpressionGenericConstant : public UMaterialExpression
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionGenericConstant">();
	}
	static class UMaterialExpressionGenericConstant* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionGenericConstant>();
	}
};
static_assert(alignof(UMaterialExpressionGenericConstant) == 0x000008, "Wrong alignment on UMaterialExpressionGenericConstant");
static_assert(sizeof(UMaterialExpressionGenericConstant) == 0x0000B0, "Wrong size on UMaterialExpressionGenericConstant");

// Class Engine.MaterialExpressionConstantDouble
// 0x0008 (0x00B8 - 0x00B0)
class UMaterialExpressionConstantDouble final : public UMaterialExpressionGenericConstant
{
public:
	double                                        Value;                                             // 0x00B0(0x0008)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionConstantDouble">();
	}
	static class UMaterialExpressionConstantDouble* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionConstantDouble>();
	}
};
static_assert(alignof(UMaterialExpressionConstantDouble) == 0x000008, "Wrong alignment on UMaterialExpressionConstantDouble");
static_assert(sizeof(UMaterialExpressionConstantDouble) == 0x0000B8, "Wrong size on UMaterialExpressionConstantDouble");
static_assert(offsetof(UMaterialExpressionConstantDouble, Value) == 0x0000B0, "Member 'UMaterialExpressionConstantDouble::Value' has a wrong offset!");

// Class Engine.ContentBundleTypeFactory
// 0x0000 (0x0028 - 0x0028)
class UContentBundleTypeFactory final : public UObject
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ContentBundleTypeFactory">();
	}
	static class UContentBundleTypeFactory* GetDefaultObj()
	{
		return GetDefaultObjImpl<UContentBundleTypeFactory>();
	}
};
static_assert(alignof(UContentBundleTypeFactory) == 0x000008, "Wrong alignment on UContentBundleTypeFactory");
static_assert(sizeof(UContentBundleTypeFactory) == 0x000028, "Wrong size on UContentBundleTypeFactory");

// Class Engine.ControlChannel
// 0x0018 (0x0080 - 0x0068)
class UControlChannel final : public UChannel
{
public:
	uint8                                         Pad_68[0x18];                                      // 0x0068(0x0018)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ControlChannel">();
	}
	static class UControlChannel* GetDefaultObj()
	{
		return GetDefaultObjImpl<UControlChannel>();
	}
};
static_assert(alignof(UControlChannel) == 0x000008, "Wrong alignment on UControlChannel");
static_assert(sizeof(UControlChannel) == 0x000080, "Wrong size on UControlChannel");

// Class Engine.ShapeComponent
// 0x0020 (0x0590 - 0x0570)
class UShapeComponent : public UPrimitiveComponent
{
public:
	class UBodySetup*                             ShapeBodySetup;                                    // 0x0570(0x0008)(ZeroConstructor, Transient, DuplicateTransient, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FColor                                 ShapeColor;                                        // 0x0578(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bDrawOnlyIfSelected : 1;                           // 0x057C(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bShouldCollideWhenPlacing : 1;                     // 0x057C(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bDynamicObstacle : 1;                              // 0x057C(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_57D[0x3];                                      // 0x057D(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	TSubclassOf<class UNavAreaBase>               AreaClassOverride;                                 // 0x0580(0x0008)(Edit, ZeroConstructor, NoDestructor, Protected, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         bUseSystemDefaultObstacleAreaClass : 1;            // 0x0588(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
	uint8                                         Pad_589[0x7];                                      // 0x0589(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ShapeComponent">();
	}
	static class UShapeComponent* GetDefaultObj()
	{
		return GetDefaultObjImpl<UShapeComponent>();
	}
};
static_assert(alignof(UShapeComponent) == 0x000010, "Wrong alignment on UShapeComponent");
static_assert(sizeof(UShapeComponent) == 0x000590, "Wrong size on UShapeComponent");
static_assert(offsetof(UShapeComponent, ShapeBodySetup) == 0x000570, "Member 'UShapeComponent::ShapeBodySetup' has a wrong offset!");
static_assert(offsetof(UShapeComponent, ShapeColor) == 0x000578, "Member 'UShapeComponent::ShapeColor' has a wrong offset!");
static_assert(offsetof(UShapeComponent, AreaClassOverride) == 0x000580, "Member 'UShapeComponent::AreaClassOverride' has a wrong offset!");

// Class Engine.CapsuleComponent
// 0x0010 (0x05A0 - 0x0590)
class UCapsuleComponent : public UShapeComponent
{
public:
	float                                         CapsuleHalfHeight;                                 // 0x0590(0x0004)(Edit, BlueprintVisible, ExportObject, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	float                                         CapsuleRadius;                                     // 0x0594(0x0004)(Edit, BlueprintVisible, ExportObject, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_598[0x8];                                      // 0x0598(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void SetCapsuleHalfHeight(float HalfHeight, bool bUpdateOverlaps);
	void SetCapsuleRadius(float Radius, bool bUpdateOverlaps);
	void SetCapsuleSize(float InRadius, float InHalfHeight, bool bUpdateOverlaps);

	float GetScaledCapsuleHalfHeight() const;
	float GetScaledCapsuleHalfHeight_WithoutHemisphere() const;
	float GetScaledCapsuleRadius() const;
	void GetScaledCapsuleSize(float* OutRadius, float* OutHalfHeight) const;
	void GetScaledCapsuleSize_WithoutHemisphere(float* OutRadius, float* OutHalfHeightWithoutHemisphere) const;
	float GetShapeScale() const;
	float GetUnscaledCapsuleHalfHeight() const;
	float GetUnscaledCapsuleHalfHeight_WithoutHemisphere() const;
	float GetUnscaledCapsuleRadius() const;
	void GetUnscaledCapsuleSize(float* OutRadius, float* OutHalfHeight) const;
	void GetUnscaledCapsuleSize_WithoutHemisphere(float* OutRadius, float* OutHalfHeightWithoutHemisphere) const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"CapsuleComponent">();
	}
	static class UCapsuleComponent* GetDefaultObj()
	{
		return GetDefaultObjImpl<UCapsuleComponent>();
	}
};
static_assert(alignof(UCapsuleComponent) == 0x000010, "Wrong alignment on UCapsuleComponent");
static_assert(sizeof(UCapsuleComponent) == 0x0005A0, "Wrong size on UCapsuleComponent");
static_assert(offsetof(UCapsuleComponent, CapsuleHalfHeight) == 0x000590, "Member 'UCapsuleComponent::CapsuleHalfHeight' has a wrong offset!");
static_assert(offsetof(UCapsuleComponent, CapsuleRadius) == 0x000594, "Member 'UCapsuleComponent::CapsuleRadius' has a wrong offset!");

// Class Engine.MaterialExpressionObjectPositionWS
// 0x0008 (0x00B8 - 0x00B0)
class UMaterialExpressionObjectPositionWS final : public UMaterialExpression
{
public:
	EPositionOrigin                               OriginType;                                        // 0x00B0(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_B1[0x7];                                       // 0x00B1(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionObjectPositionWS">();
	}
	static class UMaterialExpressionObjectPositionWS* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionObjectPositionWS>();
	}
};
static_assert(alignof(UMaterialExpressionObjectPositionWS) == 0x000008, "Wrong alignment on UMaterialExpressionObjectPositionWS");
static_assert(sizeof(UMaterialExpressionObjectPositionWS) == 0x0000B8, "Wrong size on UMaterialExpressionObjectPositionWS");
static_assert(offsetof(UMaterialExpressionObjectPositionWS, OriginType) == 0x0000B0, "Member 'UMaterialExpressionObjectPositionWS::OriginType' has a wrong offset!");

// Class Engine.WorldPartition
// 0x00D8 (0x0100 - 0x0028)
class alignas(0x10) UWorldPartition final : public UObject
{
public:
	uint8                                         Pad_28[0x8];                                       // 0x0028(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	class UActorDescContainer*                    ActorDescContainer;                                // 0x0030(0x0008)(ZeroConstructor, Transient, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UWorldPartitionRuntimeHash*             RuntimeHash;                                       // 0x0038(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bEnableStreaming;                                  // 0x0040(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EWorldPartitionServerStreamingMode            ServerStreamingMode;                               // 0x0041(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EWorldPartitionServerStreamingOutMode         ServerStreamingOutMode;                            // 0x0042(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_43[0x9D];                                      // 0x0043(0x009D)(Fixing Size After Last Property [ Dumper-7 ])
	class UDataLayerManager*                      DataLayerManager;                                  // 0x00E0(0x0008)(ZeroConstructor, Transient, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	class UWorldPartitionStreamingPolicy*         StreamingPolicy;                                   // 0x00E8(0x0008)(ZeroConstructor, Transient, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_F0[0x10];                                      // 0x00F0(0x0010)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"WorldPartition">();
	}
	static class UWorldPartition* GetDefaultObj()
	{
		return GetDefaultObjImpl<UWorldPartition>();
	}
};
static_assert(alignof(UWorldPartition) == 0x000010, "Wrong alignment on UWorldPartition");
static_assert(sizeof(UWorldPartition) == 0x000100, "Wrong size on UWorldPartition");
static_assert(offsetof(UWorldPartition, ActorDescContainer) == 0x000030, "Member 'UWorldPartition::ActorDescContainer' has a wrong offset!");
static_assert(offsetof(UWorldPartition, RuntimeHash) == 0x000038, "Member 'UWorldPartition::RuntimeHash' has a wrong offset!");
static_assert(offsetof(UWorldPartition, bEnableStreaming) == 0x000040, "Member 'UWorldPartition::bEnableStreaming' has a wrong offset!");
static_assert(offsetof(UWorldPartition, ServerStreamingMode) == 0x000041, "Member 'UWorldPartition::ServerStreamingMode' has a wrong offset!");
static_assert(offsetof(UWorldPartition, ServerStreamingOutMode) == 0x000042, "Member 'UWorldPartition::ServerStreamingOutMode' has a wrong offset!");
static_assert(offsetof(UWorldPartition, DataLayerManager) == 0x0000E0, "Member 'UWorldPartition::DataLayerManager' has a wrong offset!");
static_assert(offsetof(UWorldPartition, StreamingPolicy) == 0x0000E8, "Member 'UWorldPartition::StreamingPolicy' has a wrong offset!");

// Class Engine.AnimClassData
// 0x0230 (0x0258 - 0x0028)
class UAnimClassData final : public UObject
{
public:
	uint8                                         Pad_28[0x8];                                       // 0x0028(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<struct FBakedAnimationStateMachine>    BakedStateMachines;                                // 0x0030(0x0010)(ZeroConstructor, NativeAccessSpecifierPublic)
	class USkeleton*                              TargetSkeleton;                                    // 0x0040(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TArray<struct FAnimNotifyEvent>               AnimNotifies;                                      // 0x0048(0x0010)(ZeroConstructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
	TMap<class FName, struct FCachedPoseIndices>  OrderedSavedPoseIndicesMap;                        // 0x0058(0x0050)(NativeAccessSpecifierPublic)
	TArray<struct FAnimBlueprintFunction>         AnimBlueprintFunctions;                            // 0x00A8(0x0010)(ZeroConstructor, NativeAccessSpecifierPublic)
	TArray<struct FAnimBlueprintFunctionData>     AnimBlueprintFunctionData;                         // 0x00B8(0x0010)(ZeroConstructor, NativeAccessSpecifierPublic)
	TArray<TFieldPath<class FStructProperty>>     AnimNodeProperties;                                // 0x00C8(0x0010)(ZeroConstructor, NativeAccessSpecifierPublic)
	uint8                                         Pad_D8[0x10];                                      // 0x00D8(0x0010)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<TFieldPath<class FStructProperty>>     LinkedAnimGraphNodeProperties;                     // 0x00E8(0x0010)(ZeroConstructor, NativeAccessSpecifierPublic)
	uint8                                         Pad_F8[0x10];                                      // 0x00F8(0x0010)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<TFieldPath<class FStructProperty>>     LinkedAnimLayerNodeProperties;                     // 0x0108(0x0010)(ZeroConstructor, NativeAccessSpecifierPublic)
	uint8                                         Pad_118[0x10];                                     // 0x0118(0x0010)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<TFieldPath<class FStructProperty>>     PreUpdateNodeProperties;                           // 0x0128(0x0010)(ZeroConstructor, NativeAccessSpecifierPublic)
	uint8                                         Pad_138[0x10];                                     // 0x0138(0x0010)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<TFieldPath<class FStructProperty>>     DynamicResetNodeProperties;                        // 0x0148(0x0010)(ZeroConstructor, NativeAccessSpecifierPublic)
	uint8                                         Pad_158[0x10];                                     // 0x0158(0x0010)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<TFieldPath<class FStructProperty>>     StateMachineNodeProperties;                        // 0x0168(0x0010)(ZeroConstructor, NativeAccessSpecifierPublic)
	uint8                                         Pad_178[0x10];                                     // 0x0178(0x0010)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<TFieldPath<class FStructProperty>>     InitializationNodeProperties;                      // 0x0188(0x0010)(ZeroConstructor, NativeAccessSpecifierPublic)
	uint8                                         Pad_198[0x10];                                     // 0x0198(0x0010)(Fixing Size After Last Property [ Dumper-7 ])
	TMap<class FName, struct FGraphAssetPlayerInformation> GraphNameAssetPlayers;                    // 0x01A8(0x0050)(NativeAccessSpecifierPublic)
	TArray<class FName>                           SyncGroupNames;                                    // 0x01F8(0x0010)(ZeroConstructor, NativeAccessSpecifierPublic)
	TMap<class FName, struct FAnimGraphBlendOptions> GraphBlendOptions;                              // 0x0208(0x0050)(NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AnimClassData">();
	}
	static class UAnimClassData* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAnimClassData>();
	}
};
static_assert(alignof(UAnimClassData) == 0x000008, "Wrong alignment on UAnimClassData");
static_assert(sizeof(UAnimClassData) == 0x000258, "Wrong size on UAnimClassData");
static_assert(offsetof(UAnimClassData, BakedStateMachines) == 0x000030, "Member 'UAnimClassData::BakedStateMachines' has a wrong offset!");
static_assert(offsetof(UAnimClassData, TargetSkeleton) == 0x000040, "Member 'UAnimClassData::TargetSkeleton' has a wrong offset!");
static_assert(offsetof(UAnimClassData, AnimNotifies) == 0x000048, "Member 'UAnimClassData::AnimNotifies' has a wrong offset!");
static_assert(offsetof(UAnimClassData, OrderedSavedPoseIndicesMap) == 0x000058, "Member 'UAnimClassData::OrderedSavedPoseIndicesMap' has a wrong offset!");
static_assert(offsetof(UAnimClassData, AnimBlueprintFunctions) == 0x0000A8, "Member 'UAnimClassData::AnimBlueprintFunctions' has a wrong offset!");
static_assert(offsetof(UAnimClassData, AnimBlueprintFunctionData) == 0x0000B8, "Member 'UAnimClassData::AnimBlueprintFunctionData' has a wrong offset!");
static_assert(offsetof(UAnimClassData, AnimNodeProperties) == 0x0000C8, "Member 'UAnimClassData::AnimNodeProperties' has a wrong offset!");
static_assert(offsetof(UAnimClassData, LinkedAnimGraphNodeProperties) == 0x0000E8, "Member 'UAnimClassData::LinkedAnimGraphNodeProperties' has a wrong offset!");
static_assert(offsetof(UAnimClassData, LinkedAnimLayerNodeProperties) == 0x000108, "Member 'UAnimClassData::LinkedAnimLayerNodeProperties' has a wrong offset!");
static_assert(offsetof(UAnimClassData, PreUpdateNodeProperties) == 0x000128, "Member 'UAnimClassData::PreUpdateNodeProperties' has a wrong offset!");
static_assert(offsetof(UAnimClassData, DynamicResetNodeProperties) == 0x000148, "Member 'UAnimClassData::DynamicResetNodeProperties' has a wrong offset!");
static_assert(offsetof(UAnimClassData, StateMachineNodeProperties) == 0x000168, "Member 'UAnimClassData::StateMachineNodeProperties' has a wrong offset!");
static_assert(offsetof(UAnimClassData, InitializationNodeProperties) == 0x000188, "Member 'UAnimClassData::InitializationNodeProperties' has a wrong offset!");
static_assert(offsetof(UAnimClassData, GraphNameAssetPlayers) == 0x0001A8, "Member 'UAnimClassData::GraphNameAssetPlayers' has a wrong offset!");
static_assert(offsetof(UAnimClassData, SyncGroupNames) == 0x0001F8, "Member 'UAnimClassData::SyncGroupNames' has a wrong offset!");
static_assert(offsetof(UAnimClassData, GraphBlendOptions) == 0x000208, "Member 'UAnimClassData::GraphBlendOptions' has a wrong offset!");

// Class Engine.DataLayerManager
// 0x00B0 (0x00D8 - 0x0028)
class UDataLayerManager final : public UObject
{
public:
	TMulticastInlineDelegate<void(const class UDataLayerInstance* DataLayer, EDataLayerRuntimeState State)> OnDataLayerInstanceRuntimeStateChanged; // 0x0028(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	TSet<class UObject*>                          ReferencedObjects;                                 // 0x0038(0x0050)(Transient, UObjectWrapper, NativeAccessSpecifierPrivate)
	uint8                                         Pad_88[0x50];                                      // 0x0088(0x0050)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	bool SetDataLayerInstanceRuntimeState(const class UDataLayerInstance* InDataLayerInstance, EDataLayerRuntimeState InState, bool bInIsRecursive);
	bool SetDataLayerRuntimeState(const class UDataLayerAsset* InDataLayerAsset, EDataLayerRuntimeState InState, bool bInIsRecursive);

	EDataLayerRuntimeState GetDataLayerInstanceEffectiveRuntimeState(const class UDataLayerInstance* InDataLayerInstance) const;
	const class UDataLayerInstance* GetDataLayerInstanceFromAsset(const class UDataLayerAsset* InDataLayerAsset) const;
	const class UDataLayerInstance* GetDataLayerInstanceFromName(const class FName& InDataLayerInstanceName) const;
	EDataLayerRuntimeState GetDataLayerInstanceRuntimeState(const class UDataLayerInstance* InDataLayerInstance) const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"DataLayerManager">();
	}
	static class UDataLayerManager* GetDefaultObj()
	{
		return GetDefaultObjImpl<UDataLayerManager>();
	}
};
static_assert(alignof(UDataLayerManager) == 0x000008, "Wrong alignment on UDataLayerManager");
static_assert(sizeof(UDataLayerManager) == 0x0000D8, "Wrong size on UDataLayerManager");
static_assert(offsetof(UDataLayerManager, OnDataLayerInstanceRuntimeStateChanged) == 0x000028, "Member 'UDataLayerManager::OnDataLayerInstanceRuntimeStateChanged' has a wrong offset!");
static_assert(offsetof(UDataLayerManager, ReferencedObjects) == 0x000038, "Member 'UDataLayerManager::ReferencedObjects' has a wrong offset!");

// Class Engine.Light
// 0x0010 (0x02B0 - 0x02A0)
class ALight : public AActor
{
public:
	class ULightComponent*                        LightComponent;                                    // 0x02A0(0x0008)(BlueprintVisible, ExportObject, BlueprintReadOnly, ZeroConstructor, InstancedReference, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         bEnabled : 1;                                      // 0x02A8(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Net, RepNotify, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_2A9[0x7];                                      // 0x02A9(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void OnRep_bEnabled();
	void SetAffectTranslucentLighting(bool bNewValue);
	void SetBrightness(float NewBrightness);
	void SetCastShadows(bool bNewValue);
	void SetEnabled(bool bSetEnabled);
	void SetLightColor(const struct FLinearColor& NewLightColor);
	void SetLightFunctionFadeDistance(float NewLightFunctionFadeDistance);
	void SetLightFunctionMaterial(class UMaterialInterface* NewLightFunctionMaterial);
	void SetLightFunctionScale(const struct FVector& NewLightFunctionScale);
	void ToggleEnabled();

	float GetBrightness() const;
	struct FLinearColor GetLightColor() const;
	bool IsEnabled() const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"Light">();
	}
	static class ALight* GetDefaultObj()
	{
		return GetDefaultObjImpl<ALight>();
	}
};
static_assert(alignof(ALight) == 0x000008, "Wrong alignment on ALight");
static_assert(sizeof(ALight) == 0x0002B0, "Wrong size on ALight");
static_assert(offsetof(ALight, LightComponent) == 0x0002A0, "Member 'ALight::LightComponent' has a wrong offset!");

// Class Engine.RectLight
// 0x0008 (0x02B8 - 0x02B0)
class ARectLight final : public ALight
{
public:
	class URectLightComponent*                    RectLightComponent;                                // 0x02B0(0x0008)(Edit, BlueprintVisible, ExportObject, BlueprintReadOnly, ZeroConstructor, EditConst, InstancedReference, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"RectLight">();
	}
	static class ARectLight* GetDefaultObj()
	{
		return GetDefaultObjImpl<ARectLight>();
	}
};
static_assert(alignof(ARectLight) == 0x000008, "Wrong alignment on ARectLight");
static_assert(sizeof(ARectLight) == 0x0002B8, "Wrong size on ARectLight");
static_assert(offsetof(ARectLight, RectLightComponent) == 0x0002B0, "Member 'ARectLight::RectLightComponent' has a wrong offset!");

// Class Engine.MaterialExpressionComponentMask
// 0x0030 (0x00E0 - 0x00B0)
class UMaterialExpressionComponentMask final : public UMaterialExpression
{
public:
	struct FExpressionInput                       Input;                                             // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	uint8                                         R : 1;                                             // 0x00D8(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         G : 1;                                             // 0x00D8(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         B : 1;                                             // 0x00D8(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         A : 1;                                             // 0x00D8(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_D9[0x7];                                       // 0x00D9(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionComponentMask">();
	}
	static class UMaterialExpressionComponentMask* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionComponentMask>();
	}
};
static_assert(alignof(UMaterialExpressionComponentMask) == 0x000008, "Wrong alignment on UMaterialExpressionComponentMask");
static_assert(sizeof(UMaterialExpressionComponentMask) == 0x0000E0, "Wrong size on UMaterialExpressionComponentMask");
static_assert(offsetof(UMaterialExpressionComponentMask, Input) == 0x0000B0, "Member 'UMaterialExpressionComponentMask::Input' has a wrong offset!");

// Class Engine.DebugGarbageCollectionGraph
// 0x0020 (0x0048 - 0x0028)
class UDebugGarbageCollectionGraph final : public UObject
{
public:
	uint8                                         Pad_28[0x20];                                      // 0x0028(0x0020)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"DebugGarbageCollectionGraph">();
	}
	static class UDebugGarbageCollectionGraph* GetDefaultObj()
	{
		return GetDefaultObjImpl<UDebugGarbageCollectionGraph>();
	}
};
static_assert(alignof(UDebugGarbageCollectionGraph) == 0x000008, "Wrong alignment on UDebugGarbageCollectionGraph");
static_assert(sizeof(UDebugGarbageCollectionGraph) == 0x000048, "Wrong size on UDebugGarbageCollectionGraph");

// Class Engine.AsyncActionLoadPrimaryAssetClass
// 0x0010 (0x0088 - 0x0078)
class UAsyncActionLoadPrimaryAssetClass final : public UAsyncActionLoadPrimaryAssetBase
{
public:
	TMulticastInlineDelegate<void(TSubclassOf<class UObject> Loaded)> Completed;                     // 0x0078(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)

public:
	static class UAsyncActionLoadPrimaryAssetClass* AsyncLoadPrimaryAssetClass(class UObject* WorldContextObject, const struct FPrimaryAssetId& PrimaryAsset, const TArray<class FName>& LoadBundles);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AsyncActionLoadPrimaryAssetClass">();
	}
	static class UAsyncActionLoadPrimaryAssetClass* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAsyncActionLoadPrimaryAssetClass>();
	}
};
static_assert(alignof(UAsyncActionLoadPrimaryAssetClass) == 0x000008, "Wrong alignment on UAsyncActionLoadPrimaryAssetClass");
static_assert(sizeof(UAsyncActionLoadPrimaryAssetClass) == 0x000088, "Wrong size on UAsyncActionLoadPrimaryAssetClass");
static_assert(offsetof(UAsyncActionLoadPrimaryAssetClass, Completed) == 0x000078, "Member 'UAsyncActionLoadPrimaryAssetClass::Completed' has a wrong offset!");

// Class Engine.DemoNetConnection
// 0x0050 (0x1E48 - 0x1DF8)
class UDemoNetConnection final : public UNetConnection
{
public:
	uint8                                         Pad_1DF8[0x50];                                    // 0x1DF8(0x0050)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"DemoNetConnection">();
	}
	static class UDemoNetConnection* GetDefaultObj()
	{
		return GetDefaultObjImpl<UDemoNetConnection>();
	}
};
static_assert(alignof(UDemoNetConnection) == 0x000008, "Wrong alignment on UDemoNetConnection");
static_assert(sizeof(UDemoNetConnection) == 0x001E48, "Wrong size on UDemoNetConnection");

// Class Engine.PendingNetGame
// 0x0098 (0x00C0 - 0x0028)
class UPendingNetGame : public UObject
{
public:
	uint8                                         Pad_28[0x8];                                       // 0x0028(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	class UNetDriver*                             NetDriver;                                         // 0x0030(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UDemoNetDriver*                         DemoNetDriver;                                     // 0x0038(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_40[0x80];                                      // 0x0040(0x0080)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"PendingNetGame">();
	}
	static class UPendingNetGame* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPendingNetGame>();
	}
};
static_assert(alignof(UPendingNetGame) == 0x000008, "Wrong alignment on UPendingNetGame");
static_assert(sizeof(UPendingNetGame) == 0x0000C0, "Wrong size on UPendingNetGame");
static_assert(offsetof(UPendingNetGame, NetDriver) == 0x000030, "Member 'UPendingNetGame::NetDriver' has a wrong offset!");
static_assert(offsetof(UPendingNetGame, DemoNetDriver) == 0x000038, "Member 'UPendingNetGame::DemoNetDriver' has a wrong offset!");

// Class Engine.MaterialExpressionCameraVectorWS
// 0x0000 (0x00B0 - 0x00B0)
class UMaterialExpressionCameraVectorWS final : public UMaterialExpression
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionCameraVectorWS">();
	}
	static class UMaterialExpressionCameraVectorWS* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionCameraVectorWS>();
	}
};
static_assert(alignof(UMaterialExpressionCameraVectorWS) == 0x000008, "Wrong alignment on UMaterialExpressionCameraVectorWS");
static_assert(sizeof(UMaterialExpressionCameraVectorWS) == 0x0000B0, "Wrong size on UMaterialExpressionCameraVectorWS");

// Class Engine.DemoPendingNetGame
// 0x0000 (0x00C0 - 0x00C0)
class UDemoPendingNetGame final : public UPendingNetGame
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"DemoPendingNetGame">();
	}
	static class UDemoPendingNetGame* GetDefaultObj()
	{
		return GetDefaultObjImpl<UDemoPendingNetGame>();
	}
};
static_assert(alignof(UDemoPendingNetGame) == 0x000008, "Wrong alignment on UDemoPendingNetGame");
static_assert(sizeof(UDemoPendingNetGame) == 0x0000C0, "Wrong size on UDemoPendingNetGame");

// Class Engine.BoxComponent
// 0x0020 (0x05B0 - 0x0590)
class UBoxComponent : public UShapeComponent
{
public:
	struct FVector                                BoxExtent;                                         // 0x0590(0x0018)(Edit, BlueprintVisible, ExportObject, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	float                                         LineThickness;                                     // 0x05A8(0x0004)(Edit, BlueprintVisible, ExportObject, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_5AC[0x4];                                      // 0x05AC(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void SetBoxExtent(const struct FVector& InBoxExtent, bool bUpdateOverlaps);
	void SetLineThickness(float Thickness);

	struct FVector GetScaledBoxExtent() const;
	struct FVector GetUnscaledBoxExtent() const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"BoxComponent">();
	}
	static class UBoxComponent* GetDefaultObj()
	{
		return GetDefaultObjImpl<UBoxComponent>();
	}
};
static_assert(alignof(UBoxComponent) == 0x000010, "Wrong alignment on UBoxComponent");
static_assert(sizeof(UBoxComponent) == 0x0005B0, "Wrong size on UBoxComponent");
static_assert(offsetof(UBoxComponent, BoxExtent) == 0x000590, "Member 'UBoxComponent::BoxExtent' has a wrong offset!");
static_assert(offsetof(UBoxComponent, LineThickness) == 0x0005A8, "Member 'UBoxComponent::LineThickness' has a wrong offset!");

// Class Engine.ActorTextureStreamingBuildDataComponent
// 0x0000 (0x00A8 - 0x00A8)
class UActorTextureStreamingBuildDataComponent final : public UActorComponent
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ActorTextureStreamingBuildDataComponent">();
	}
	static class UActorTextureStreamingBuildDataComponent* GetDefaultObj()
	{
		return GetDefaultObjImpl<UActorTextureStreamingBuildDataComponent>();
	}
};
static_assert(alignof(UActorTextureStreamingBuildDataComponent) == 0x000008, "Wrong alignment on UActorTextureStreamingBuildDataComponent");
static_assert(sizeof(UActorTextureStreamingBuildDataComponent) == 0x0000A8, "Wrong size on UActorTextureStreamingBuildDataComponent");

// Class Engine.MaterialExpressionClearCoatNormalCustomOutput
// 0x0028 (0x00D8 - 0x00B0)
class UMaterialExpressionClearCoatNormalCustomOutput final : public UMaterialExpressionCustomOutput
{
public:
	struct FExpressionInput                       Input;                                             // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionClearCoatNormalCustomOutput">();
	}
	static class UMaterialExpressionClearCoatNormalCustomOutput* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionClearCoatNormalCustomOutput>();
	}
};
static_assert(alignof(UMaterialExpressionClearCoatNormalCustomOutput) == 0x000008, "Wrong alignment on UMaterialExpressionClearCoatNormalCustomOutput");
static_assert(sizeof(UMaterialExpressionClearCoatNormalCustomOutput) == 0x0000D8, "Wrong size on UMaterialExpressionClearCoatNormalCustomOutput");
static_assert(offsetof(UMaterialExpressionClearCoatNormalCustomOutput, Input) == 0x0000B0, "Member 'UMaterialExpressionClearCoatNormalCustomOutput::Input' has a wrong offset!");

// Class Engine.DeviceProfileFragment
// 0x0010 (0x0038 - 0x0028)
class UDeviceProfileFragment final : public UObject
{
public:
	TArray<class FString>                         CVars;                                             // 0x0028(0x0010)(ZeroConstructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"DeviceProfileFragment">();
	}
	static class UDeviceProfileFragment* GetDefaultObj()
	{
		return GetDefaultObjImpl<UDeviceProfileFragment>();
	}
};
static_assert(alignof(UDeviceProfileFragment) == 0x000008, "Wrong alignment on UDeviceProfileFragment");
static_assert(sizeof(UDeviceProfileFragment) == 0x000038, "Wrong size on UDeviceProfileFragment");
static_assert(offsetof(UDeviceProfileFragment, CVars) == 0x000028, "Member 'UDeviceProfileFragment::CVars' has a wrong offset!");

// Class Engine.DialogueSoundWaveProxy
// 0x0018 (0x0180 - 0x0168)
class UDialogueSoundWaveProxy final : public USoundBase
{
public:
	uint8                                         Pad_168[0x18];                                     // 0x0168(0x0018)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"DialogueSoundWaveProxy">();
	}
	static class UDialogueSoundWaveProxy* GetDefaultObj()
	{
		return GetDefaultObjImpl<UDialogueSoundWaveProxy>();
	}
};
static_assert(alignof(UDialogueSoundWaveProxy) == 0x000008, "Wrong alignment on UDialogueSoundWaveProxy");
static_assert(sizeof(UDialogueSoundWaveProxy) == 0x000180, "Wrong size on UDialogueSoundWaveProxy");

// Class Engine.AnimBlueprint
// 0x0028 (0x00D0 - 0x00A8)
class UAnimBlueprint final : public UBlueprint
{
public:
	uint8                                         Pad_A8[0x8];                                       // 0x00A8(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	class USkeleton*                              TargetSkeleton;                                    // 0x00B0(0x0008)(Edit, ZeroConstructor, NoDestructor, AssetRegistrySearchable, AdvancedDisplay, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TArray<struct FAnimGroupInfo>                 Groups;                                            // 0x00B8(0x0010)(ZeroConstructor, NativeAccessSpecifierPublic)
	bool                                          bIsTemplate;                                       // 0x00C8(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, AssetRegistrySearchable, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bUseMultiThreadedAnimationUpdate;                  // 0x00C9(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bWarnAboutBlueprintUsage;                          // 0x00CA(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bEnableLinkedAnimLayerInstanceSharing : 1;         // 0x00CB(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, DisableEditOnInstance, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_CC[0x4];                                       // 0x00CC(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AnimBlueprint">();
	}
	static class UAnimBlueprint* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAnimBlueprint>();
	}
};
static_assert(alignof(UAnimBlueprint) == 0x000008, "Wrong alignment on UAnimBlueprint");
static_assert(sizeof(UAnimBlueprint) == 0x0000D0, "Wrong size on UAnimBlueprint");
static_assert(offsetof(UAnimBlueprint, TargetSkeleton) == 0x0000B0, "Member 'UAnimBlueprint::TargetSkeleton' has a wrong offset!");
static_assert(offsetof(UAnimBlueprint, Groups) == 0x0000B8, "Member 'UAnimBlueprint::Groups' has a wrong offset!");
static_assert(offsetof(UAnimBlueprint, bIsTemplate) == 0x0000C8, "Member 'UAnimBlueprint::bIsTemplate' has a wrong offset!");
static_assert(offsetof(UAnimBlueprint, bUseMultiThreadedAnimationUpdate) == 0x0000C9, "Member 'UAnimBlueprint::bUseMultiThreadedAnimationUpdate' has a wrong offset!");
static_assert(offsetof(UAnimBlueprint, bWarnAboutBlueprintUsage) == 0x0000CA, "Member 'UAnimBlueprint::bWarnAboutBlueprintUsage' has a wrong offset!");

// Class Engine.MaterialExpressionDynamicParameter
// 0x0028 (0x00D8 - 0x00B0)
class UMaterialExpressionDynamicParameter final : public UMaterialExpression
{
public:
	TArray<class FString>                         ParamNames;                                        // 0x00B0(0x0010)(Edit, EditFixedSize, ZeroConstructor, NativeAccessSpecifierPublic)
	struct FLinearColor                           DefaultValue;                                      // 0x00C0(0x0010)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint32                                        ParameterIndex;                                    // 0x00D0(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_D4[0x4];                                       // 0x00D4(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionDynamicParameter">();
	}
	static class UMaterialExpressionDynamicParameter* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionDynamicParameter>();
	}
};
static_assert(alignof(UMaterialExpressionDynamicParameter) == 0x000008, "Wrong alignment on UMaterialExpressionDynamicParameter");
static_assert(sizeof(UMaterialExpressionDynamicParameter) == 0x0000D8, "Wrong size on UMaterialExpressionDynamicParameter");
static_assert(offsetof(UMaterialExpressionDynamicParameter, ParamNames) == 0x0000B0, "Member 'UMaterialExpressionDynamicParameter::ParamNames' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionDynamicParameter, DefaultValue) == 0x0000C0, "Member 'UMaterialExpressionDynamicParameter::DefaultValue' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionDynamicParameter, ParameterIndex) == 0x0000D0, "Member 'UMaterialExpressionDynamicParameter::ParameterIndex' has a wrong offset!");

// Class Engine.MaterialExpressionStrataVerticalLayering
// 0x0080 (0x0130 - 0x00B0)
class UMaterialExpressionStrataVerticalLayering final : public UMaterialExpressionStrataBSDF
{
public:
	struct FExpressionInput                       Top;                                               // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       base;                                              // 0x00D8(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       Thickness;                                         // 0x0100(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	uint8                                         bUseParameterBlending : 1;                         // 0x0128(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_129[0x7];                                      // 0x0129(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionStrataVerticalLayering">();
	}
	static class UMaterialExpressionStrataVerticalLayering* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionStrataVerticalLayering>();
	}
};
static_assert(alignof(UMaterialExpressionStrataVerticalLayering) == 0x000008, "Wrong alignment on UMaterialExpressionStrataVerticalLayering");
static_assert(sizeof(UMaterialExpressionStrataVerticalLayering) == 0x000130, "Wrong size on UMaterialExpressionStrataVerticalLayering");
static_assert(offsetof(UMaterialExpressionStrataVerticalLayering, Top) == 0x0000B0, "Member 'UMaterialExpressionStrataVerticalLayering::Top' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionStrataVerticalLayering, base) == 0x0000D8, "Member 'UMaterialExpressionStrataVerticalLayering::base' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionStrataVerticalLayering, Thickness) == 0x000100, "Member 'UMaterialExpressionStrataVerticalLayering::Thickness' has a wrong offset!");

// Class Engine.DirectionalLight
// 0x0000 (0x02B0 - 0x02B0)
class ADirectionalLight final : public ALight
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"DirectionalLight">();
	}
	static class ADirectionalLight* GetDefaultObj()
	{
		return GetDefaultObjImpl<ADirectionalLight>();
	}
};
static_assert(alignof(ADirectionalLight) == 0x000008, "Wrong alignment on ADirectionalLight");
static_assert(sizeof(ADirectionalLight) == 0x0002B0, "Wrong size on ADirectionalLight");

// Class Engine.Distribution
// 0x0008 (0x0030 - 0x0028)
class UDistribution : public UObject
{
public:
	uint8                                         Pad_28[0x8];                                       // 0x0028(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"Distribution">();
	}
	static class UDistribution* GetDefaultObj()
	{
		return GetDefaultObjImpl<UDistribution>();
	}
};
static_assert(alignof(UDistribution) == 0x000008, "Wrong alignment on UDistribution");
static_assert(sizeof(UDistribution) == 0x000030, "Wrong size on UDistribution");

// Class Engine.SMInstanceElementPrimitiveCustomDataInterface
// 0x0008 (0x0030 - 0x0028)
class USMInstanceElementPrimitiveCustomDataInterface final : public UObject
{
public:
	uint8                                         Pad_28[0x8];                                       // 0x0028(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"SMInstanceElementPrimitiveCustomDataInterface">();
	}
	static class USMInstanceElementPrimitiveCustomDataInterface* GetDefaultObj()
	{
		return GetDefaultObjImpl<USMInstanceElementPrimitiveCustomDataInterface>();
	}
};
static_assert(alignof(USMInstanceElementPrimitiveCustomDataInterface) == 0x000008, "Wrong alignment on USMInstanceElementPrimitiveCustomDataInterface");
static_assert(sizeof(USMInstanceElementPrimitiveCustomDataInterface) == 0x000030, "Wrong size on USMInstanceElementPrimitiveCustomDataInterface");

// Class Engine.MeshVertexPainterKismetLibrary
// 0x0000 (0x0028 - 0x0028)
class UMeshVertexPainterKismetLibrary final : public UBlueprintFunctionLibrary
{
public:
	static void PaintVerticesLerpAlongAxis(class UStaticMeshComponent* StaticMeshComponent, const struct FLinearColor& StartColor, const struct FLinearColor& EndColor, EVertexPaintAxis Axis, bool bConvertToSRGB);
	static void PaintVerticesSingleColor(class UStaticMeshComponent* StaticMeshComponent, const struct FLinearColor& FillColor, bool bConvertToSRGB);
	static void RemovePaintedVertices(class UStaticMeshComponent* StaticMeshComponent);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MeshVertexPainterKismetLibrary">();
	}
	static class UMeshVertexPainterKismetLibrary* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMeshVertexPainterKismetLibrary>();
	}
};
static_assert(alignof(UMeshVertexPainterKismetLibrary) == 0x000008, "Wrong alignment on UMeshVertexPainterKismetLibrary");
static_assert(sizeof(UMeshVertexPainterKismetLibrary) == 0x000028, "Wrong size on UMeshVertexPainterKismetLibrary");

// Class Engine.MaterialExpressionVolumetricAdvancedMaterialInput
// 0x0000 (0x00B0 - 0x00B0)
class UMaterialExpressionVolumetricAdvancedMaterialInput final : public UMaterialExpression
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionVolumetricAdvancedMaterialInput">();
	}
	static class UMaterialExpressionVolumetricAdvancedMaterialInput* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionVolumetricAdvancedMaterialInput>();
	}
};
static_assert(alignof(UMaterialExpressionVolumetricAdvancedMaterialInput) == 0x000008, "Wrong alignment on UMaterialExpressionVolumetricAdvancedMaterialInput");
static_assert(sizeof(UMaterialExpressionVolumetricAdvancedMaterialInput) == 0x0000B0, "Wrong size on UMaterialExpressionVolumetricAdvancedMaterialInput");

// Class Engine.DistributionFloat
// 0x0008 (0x0038 - 0x0030)
class UDistributionFloat : public UDistribution
{
public:
	uint8                                         bCanBeBaked : 1;                                   // 0x0030(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         BitPad_30_1 : 1;                                   // 0x0030(0x0001)(Fixing Bit-Field Size Between Bits [ Dumper-7 ])
	uint8                                         bBakedDataSuccesfully : 1;                         // 0x0030(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
	uint8                                         Pad_31[0x7];                                       // 0x0031(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"DistributionFloat">();
	}
	static class UDistributionFloat* GetDefaultObj()
	{
		return GetDefaultObjImpl<UDistributionFloat>();
	}
};
static_assert(alignof(UDistributionFloat) == 0x000008, "Wrong alignment on UDistributionFloat");
static_assert(sizeof(UDistributionFloat) == 0x000038, "Wrong size on UDistributionFloat");

// Class Engine.DistributionFloatConstant
// 0x0008 (0x0040 - 0x0038)
class UDistributionFloatConstant : public UDistributionFloat
{
public:
	float                                         Constant;                                          // 0x0038(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_3C[0x4];                                       // 0x003C(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"DistributionFloatConstant">();
	}
	static class UDistributionFloatConstant* GetDefaultObj()
	{
		return GetDefaultObjImpl<UDistributionFloatConstant>();
	}
};
static_assert(alignof(UDistributionFloatConstant) == 0x000008, "Wrong alignment on UDistributionFloatConstant");
static_assert(sizeof(UDistributionFloatConstant) == 0x000040, "Wrong size on UDistributionFloatConstant");
static_assert(offsetof(UDistributionFloatConstant, Constant) == 0x000038, "Member 'UDistributionFloatConstant::Constant' has a wrong offset!");

// Class Engine.ObjectElementCounterInterface
// 0x0008 (0x0030 - 0x0028)
class UObjectElementCounterInterface final : public UObject
{
public:
	uint8                                         Pad_28[0x8];                                       // 0x0028(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ObjectElementCounterInterface">();
	}
	static class UObjectElementCounterInterface* GetDefaultObj()
	{
		return GetDefaultObjImpl<UObjectElementCounterInterface>();
	}
};
static_assert(alignof(UObjectElementCounterInterface) == 0x000008, "Wrong alignment on UObjectElementCounterInterface");
static_assert(sizeof(UObjectElementCounterInterface) == 0x000030, "Wrong size on UObjectElementCounterInterface");

// Class Engine.DistributionFloatConstantCurve
// 0x0018 (0x0050 - 0x0038)
class UDistributionFloatConstantCurve final : public UDistributionFloat
{
public:
	struct FInterpCurveFloat                      ConstantCurve;                                     // 0x0038(0x0018)(Edit, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"DistributionFloatConstantCurve">();
	}
	static class UDistributionFloatConstantCurve* GetDefaultObj()
	{
		return GetDefaultObjImpl<UDistributionFloatConstantCurve>();
	}
};
static_assert(alignof(UDistributionFloatConstantCurve) == 0x000008, "Wrong alignment on UDistributionFloatConstantCurve");
static_assert(sizeof(UDistributionFloatConstantCurve) == 0x000050, "Wrong size on UDistributionFloatConstantCurve");
static_assert(offsetof(UDistributionFloatConstantCurve, ConstantCurve) == 0x000038, "Member 'UDistributionFloatConstantCurve::ConstantCurve' has a wrong offset!");

// Class Engine.Rig
// 0x0028 (0x0050 - 0x0028)
class URig final : public UObject
{
public:
	uint8                                         Pad_28[0x8];                                       // 0x0028(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<struct FTransformBase>                 TransformBases;                                    // 0x0030(0x0010)(Edit, EditFixedSize, ZeroConstructor, NativeAccessSpecifierPrivate)
	TArray<struct FNode>                          Nodes;                                             // 0x0040(0x0010)(Edit, EditFixedSize, ZeroConstructor, NativeAccessSpecifierPrivate)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"Rig">();
	}
	static class URig* GetDefaultObj()
	{
		return GetDefaultObjImpl<URig>();
	}
};
static_assert(alignof(URig) == 0x000008, "Wrong alignment on URig");
static_assert(sizeof(URig) == 0x000050, "Wrong size on URig");
static_assert(offsetof(URig, TransformBases) == 0x000030, "Member 'URig::TransformBases' has a wrong offset!");
static_assert(offsetof(URig, Nodes) == 0x000040, "Member 'URig::Nodes' has a wrong offset!");

// Class Engine.SubsurfaceProfile
// 0x00A0 (0x00C8 - 0x0028)
class USubsurfaceProfile final : public UObject
{
public:
	struct FSubsurfaceProfileStruct               Settings;                                          // 0x0028(0x009C)(Edit, NoDestructor, NativeAccessSpecifierPublic)
	uint8                                         Pad_C4[0x4];                                       // 0x00C4(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"SubsurfaceProfile">();
	}
	static class USubsurfaceProfile* GetDefaultObj()
	{
		return GetDefaultObjImpl<USubsurfaceProfile>();
	}
};
static_assert(alignof(USubsurfaceProfile) == 0x000008, "Wrong alignment on USubsurfaceProfile");
static_assert(sizeof(USubsurfaceProfile) == 0x0000C8, "Wrong size on USubsurfaceProfile");
static_assert(offsetof(USubsurfaceProfile, Settings) == 0x000028, "Member 'USubsurfaceProfile::Settings' has a wrong offset!");

// Class Engine.MaterialExpressionConstant3Vector
// 0x0010 (0x00C0 - 0x00B0)
class UMaterialExpressionConstant3Vector final : public UMaterialExpression
{
public:
	struct FLinearColor                           Constant;                                          // 0x00B0(0x0010)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionConstant3Vector">();
	}
	static class UMaterialExpressionConstant3Vector* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionConstant3Vector>();
	}
};
static_assert(alignof(UMaterialExpressionConstant3Vector) == 0x000008, "Wrong alignment on UMaterialExpressionConstant3Vector");
static_assert(sizeof(UMaterialExpressionConstant3Vector) == 0x0000C0, "Wrong size on UMaterialExpressionConstant3Vector");
static_assert(offsetof(UMaterialExpressionConstant3Vector, Constant) == 0x0000B0, "Member 'UMaterialExpressionConstant3Vector::Constant' has a wrong offset!");

// Class Engine.DistributionFloatParameterBase
// 0x0020 (0x0060 - 0x0040)
class UDistributionFloatParameterBase : public UDistributionFloatConstant
{
public:
	class FName                                   ParameterName;                                     // 0x0040(0x0008)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         MinInput;                                          // 0x0048(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         MaxInput;                                          // 0x004C(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         MinOutput;                                         // 0x0050(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         MaxOutput;                                         // 0x0054(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EDistributionParamMode                        ParamMode;                                         // 0x0058(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_59[0x7];                                       // 0x0059(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"DistributionFloatParameterBase">();
	}
	static class UDistributionFloatParameterBase* GetDefaultObj()
	{
		return GetDefaultObjImpl<UDistributionFloatParameterBase>();
	}
};
static_assert(alignof(UDistributionFloatParameterBase) == 0x000008, "Wrong alignment on UDistributionFloatParameterBase");
static_assert(sizeof(UDistributionFloatParameterBase) == 0x000060, "Wrong size on UDistributionFloatParameterBase");
static_assert(offsetof(UDistributionFloatParameterBase, ParameterName) == 0x000040, "Member 'UDistributionFloatParameterBase::ParameterName' has a wrong offset!");
static_assert(offsetof(UDistributionFloatParameterBase, MinInput) == 0x000048, "Member 'UDistributionFloatParameterBase::MinInput' has a wrong offset!");
static_assert(offsetof(UDistributionFloatParameterBase, MaxInput) == 0x00004C, "Member 'UDistributionFloatParameterBase::MaxInput' has a wrong offset!");
static_assert(offsetof(UDistributionFloatParameterBase, MinOutput) == 0x000050, "Member 'UDistributionFloatParameterBase::MinOutput' has a wrong offset!");
static_assert(offsetof(UDistributionFloatParameterBase, MaxOutput) == 0x000054, "Member 'UDistributionFloatParameterBase::MaxOutput' has a wrong offset!");
static_assert(offsetof(UDistributionFloatParameterBase, ParamMode) == 0x000058, "Member 'UDistributionFloatParameterBase::ParamMode' has a wrong offset!");

// Class Engine.DistributionFloatParticleParameter
// 0x0000 (0x0060 - 0x0060)
class UDistributionFloatParticleParameter final : public UDistributionFloatParameterBase
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"DistributionFloatParticleParameter">();
	}
	static class UDistributionFloatParticleParameter* GetDefaultObj()
	{
		return GetDefaultObjImpl<UDistributionFloatParticleParameter>();
	}
};
static_assert(alignof(UDistributionFloatParticleParameter) == 0x000008, "Wrong alignment on UDistributionFloatParticleParameter");
static_assert(sizeof(UDistributionFloatParticleParameter) == 0x000060, "Wrong size on UDistributionFloatParticleParameter");

// Class Engine.AtmosphericFog
// 0x0008 (0x02A8 - 0x02A0)
class AAtmosphericFog final : public AInfo
{
public:
	class UAtmosphericFogComponent*               AtmosphericFogComponent;                           // 0x02A0(0x0008)(Edit, BlueprintVisible, ExportObject, BlueprintReadOnly, ZeroConstructor, EditConst, InstancedReference, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AtmosphericFog">();
	}
	static class AAtmosphericFog* GetDefaultObj()
	{
		return GetDefaultObjImpl<AAtmosphericFog>();
	}
};
static_assert(alignof(AAtmosphericFog) == 0x000008, "Wrong alignment on AAtmosphericFog");
static_assert(sizeof(AAtmosphericFog) == 0x0002A8, "Wrong size on AAtmosphericFog");
static_assert(offsetof(AAtmosphericFog, AtmosphericFogComponent) == 0x0002A0, "Member 'AAtmosphericFog::AtmosphericFogComponent' has a wrong offset!");

// Class Engine.MaterialExpressionFloor
// 0x0028 (0x00D8 - 0x00B0)
class UMaterialExpressionFloor final : public UMaterialExpression
{
public:
	struct FExpressionInput                       Input;                                             // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionFloor">();
	}
	static class UMaterialExpressionFloor* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionFloor>();
	}
};
static_assert(alignof(UMaterialExpressionFloor) == 0x000008, "Wrong alignment on UMaterialExpressionFloor");
static_assert(sizeof(UMaterialExpressionFloor) == 0x0000D8, "Wrong size on UMaterialExpressionFloor");
static_assert(offsetof(UMaterialExpressionFloor, Input) == 0x0000B0, "Member 'UMaterialExpressionFloor::Input' has a wrong offset!");

// Class Engine.DistributionFloatUniform
// 0x0008 (0x0040 - 0x0038)
class UDistributionFloatUniform final : public UDistributionFloat
{
public:
	float                                         Min;                                               // 0x0038(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         Max;                                               // 0x003C(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"DistributionFloatUniform">();
	}
	static class UDistributionFloatUniform* GetDefaultObj()
	{
		return GetDefaultObjImpl<UDistributionFloatUniform>();
	}
};
static_assert(alignof(UDistributionFloatUniform) == 0x000008, "Wrong alignment on UDistributionFloatUniform");
static_assert(sizeof(UDistributionFloatUniform) == 0x000040, "Wrong size on UDistributionFloatUniform");
static_assert(offsetof(UDistributionFloatUniform, Min) == 0x000038, "Member 'UDistributionFloatUniform::Min' has a wrong offset!");
static_assert(offsetof(UDistributionFloatUniform, Max) == 0x00003C, "Member 'UDistributionFloatUniform::Max' has a wrong offset!");

// Class Engine.MaterialExpressionSubsurfaceMediumMaterialOutput
// 0x0050 (0x0100 - 0x00B0)
class UMaterialExpressionSubsurfaceMediumMaterialOutput final : public UMaterialExpressionCustomOutput
{
public:
	struct FExpressionInput                       MeanFreePath;                                      // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       ScatteringDistribution;                            // 0x00D8(0x0028)(NoDestructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionSubsurfaceMediumMaterialOutput">();
	}
	static class UMaterialExpressionSubsurfaceMediumMaterialOutput* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionSubsurfaceMediumMaterialOutput>();
	}
};
static_assert(alignof(UMaterialExpressionSubsurfaceMediumMaterialOutput) == 0x000008, "Wrong alignment on UMaterialExpressionSubsurfaceMediumMaterialOutput");
static_assert(sizeof(UMaterialExpressionSubsurfaceMediumMaterialOutput) == 0x000100, "Wrong size on UMaterialExpressionSubsurfaceMediumMaterialOutput");
static_assert(offsetof(UMaterialExpressionSubsurfaceMediumMaterialOutput, MeanFreePath) == 0x0000B0, "Member 'UMaterialExpressionSubsurfaceMediumMaterialOutput::MeanFreePath' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionSubsurfaceMediumMaterialOutput, ScatteringDistribution) == 0x0000D8, "Member 'UMaterialExpressionSubsurfaceMediumMaterialOutput::ScatteringDistribution' has a wrong offset!");

// Class Engine.DistributionFloatUniformCurve
// 0x0018 (0x0050 - 0x0038)
class UDistributionFloatUniformCurve final : public UDistributionFloat
{
public:
	struct FInterpCurveVector2D                   ConstantCurve;                                     // 0x0038(0x0018)(Edit, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"DistributionFloatUniformCurve">();
	}
	static class UDistributionFloatUniformCurve* GetDefaultObj()
	{
		return GetDefaultObjImpl<UDistributionFloatUniformCurve>();
	}
};
static_assert(alignof(UDistributionFloatUniformCurve) == 0x000008, "Wrong alignment on UDistributionFloatUniformCurve");
static_assert(sizeof(UDistributionFloatUniformCurve) == 0x000050, "Wrong size on UDistributionFloatUniformCurve");
static_assert(offsetof(UDistributionFloatUniformCurve, ConstantCurve) == 0x000038, "Member 'UDistributionFloatUniformCurve::ConstantCurve' has a wrong offset!");

// Class Engine.ActorReplicationBridge
// 0x0020 (0x04D0 - 0x04B0)
class UActorReplicationBridge final : public UObjectReplicationBridge
{
public:
	uint8                                         Pad_4B0[0x20];                                     // 0x04B0(0x0020)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ActorReplicationBridge">();
	}
	static class UActorReplicationBridge* GetDefaultObj()
	{
		return GetDefaultObjImpl<UActorReplicationBridge>();
	}
};
static_assert(alignof(UActorReplicationBridge) == 0x000008, "Wrong alignment on UActorReplicationBridge");
static_assert(sizeof(UActorReplicationBridge) == 0x0004D0, "Wrong size on UActorReplicationBridge");

// Class Engine.MaterialExpressionDecalColor
// 0x0000 (0x00B0 - 0x00B0)
class UMaterialExpressionDecalColor final : public UMaterialExpression
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionDecalColor">();
	}
	static class UMaterialExpressionDecalColor* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionDecalColor>();
	}
};
static_assert(alignof(UMaterialExpressionDecalColor) == 0x000008, "Wrong alignment on UMaterialExpressionDecalColor");
static_assert(sizeof(UMaterialExpressionDecalColor) == 0x0000B0, "Wrong size on UMaterialExpressionDecalColor");

// Class Engine.DistributionVector
// 0x0008 (0x0038 - 0x0030)
class UDistributionVector : public UDistribution
{
public:
	uint8                                         bCanBeBaked : 1;                                   // 0x0030(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bIsDirty : 1;                                      // 0x0030(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bBakedDataSuccesfully : 1;                         // 0x0030(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
	uint8                                         Pad_31[0x7];                                       // 0x0031(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"DistributionVector">();
	}
	static class UDistributionVector* GetDefaultObj()
	{
		return GetDefaultObjImpl<UDistributionVector>();
	}
};
static_assert(alignof(UDistributionVector) == 0x000008, "Wrong alignment on UDistributionVector");
static_assert(sizeof(UDistributionVector) == 0x000038, "Wrong size on UDistributionVector");

// Class Engine.PoseWatchFolder
// 0x0000 (0x0028 - 0x0028)
class UPoseWatchFolder final : public UObject
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"PoseWatchFolder">();
	}
	static class UPoseWatchFolder* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPoseWatchFolder>();
	}
};
static_assert(alignof(UPoseWatchFolder) == 0x000008, "Wrong alignment on UPoseWatchFolder");
static_assert(sizeof(UPoseWatchFolder) == 0x000028, "Wrong size on UPoseWatchFolder");

// Class Engine.NetFaultConfig
// 0x0000 (0x0088 - 0x0088)
class UNetFaultConfig final : public UEscalationManagerConfig
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"NetFaultConfig">();
	}
	static class UNetFaultConfig* GetDefaultObj()
	{
		return GetDefaultObjImpl<UNetFaultConfig>();
	}
};
static_assert(alignof(UNetFaultConfig) == 0x000008, "Wrong alignment on UNetFaultConfig");
static_assert(sizeof(UNetFaultConfig) == 0x000088, "Wrong size on UNetFaultConfig");

// Class Engine.MaterialExpressionStaticComponentMaskParameter
// 0x0030 (0x0108 - 0x00D8)
class UMaterialExpressionStaticComponentMaskParameter final : public UMaterialExpressionParameter
{
public:
	struct FExpressionInput                       Input;                                             // 0x00D8(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	uint8                                         DefaultR : 1;                                      // 0x0100(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         DefaultG : 1;                                      // 0x0100(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         DefaultB : 1;                                      // 0x0100(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         DefaultA : 1;                                      // 0x0100(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_101[0x7];                                      // 0x0101(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionStaticComponentMaskParameter">();
	}
	static class UMaterialExpressionStaticComponentMaskParameter* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionStaticComponentMaskParameter>();
	}
};
static_assert(alignof(UMaterialExpressionStaticComponentMaskParameter) == 0x000008, "Wrong alignment on UMaterialExpressionStaticComponentMaskParameter");
static_assert(sizeof(UMaterialExpressionStaticComponentMaskParameter) == 0x000108, "Wrong size on UMaterialExpressionStaticComponentMaskParameter");
static_assert(offsetof(UMaterialExpressionStaticComponentMaskParameter, Input) == 0x0000D8, "Member 'UMaterialExpressionStaticComponentMaskParameter::Input' has a wrong offset!");

// Class Engine.DistributionVectorConstant
// 0x0020 (0x0058 - 0x0038)
class UDistributionVectorConstant : public UDistributionVector
{
public:
	struct FVector                                Constant;                                          // 0x0038(0x0018)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bLockAxes : 1;                                     // 0x0050(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_51[0x3];                                       // 0x0051(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	EDistributionVectorLockFlags                  LockedAxes;                                        // 0x0054(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_55[0x3];                                       // 0x0055(0x0003)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"DistributionVectorConstant">();
	}
	static class UDistributionVectorConstant* GetDefaultObj()
	{
		return GetDefaultObjImpl<UDistributionVectorConstant>();
	}
};
static_assert(alignof(UDistributionVectorConstant) == 0x000008, "Wrong alignment on UDistributionVectorConstant");
static_assert(sizeof(UDistributionVectorConstant) == 0x000058, "Wrong size on UDistributionVectorConstant");
static_assert(offsetof(UDistributionVectorConstant, Constant) == 0x000038, "Member 'UDistributionVectorConstant::Constant' has a wrong offset!");
static_assert(offsetof(UDistributionVectorConstant, LockedAxes) == 0x000054, "Member 'UDistributionVectorConstant::LockedAxes' has a wrong offset!");

// Class Engine.DistributionVectorConstantCurve
// 0x0020 (0x0058 - 0x0038)
class UDistributionVectorConstantCurve final : public UDistributionVector
{
public:
	struct FInterpCurveVector                     ConstantCurve;                                     // 0x0038(0x0018)(Edit, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bLockAxes : 1;                                     // 0x0050(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_51[0x3];                                       // 0x0051(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	EDistributionVectorLockFlags                  LockedAxes;                                        // 0x0054(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_55[0x3];                                       // 0x0055(0x0003)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"DistributionVectorConstantCurve">();
	}
	static class UDistributionVectorConstantCurve* GetDefaultObj()
	{
		return GetDefaultObjImpl<UDistributionVectorConstantCurve>();
	}
};
static_assert(alignof(UDistributionVectorConstantCurve) == 0x000008, "Wrong alignment on UDistributionVectorConstantCurve");
static_assert(sizeof(UDistributionVectorConstantCurve) == 0x000058, "Wrong size on UDistributionVectorConstantCurve");
static_assert(offsetof(UDistributionVectorConstantCurve, ConstantCurve) == 0x000038, "Member 'UDistributionVectorConstantCurve::ConstantCurve' has a wrong offset!");
static_assert(offsetof(UDistributionVectorConstantCurve, LockedAxes) == 0x000054, "Member 'UDistributionVectorConstantCurve::LockedAxes' has a wrong offset!");

// Class Engine.SMInstanceElementWorldInterface
// 0x0008 (0x0030 - 0x0028)
class USMInstanceElementWorldInterface final : public UObject
{
public:
	uint8                                         Pad_28[0x8];                                       // 0x0028(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"SMInstanceElementWorldInterface">();
	}
	static class USMInstanceElementWorldInterface* GetDefaultObj()
	{
		return GetDefaultObjImpl<USMInstanceElementWorldInterface>();
	}
};
static_assert(alignof(USMInstanceElementWorldInterface) == 0x000008, "Wrong alignment on USMInstanceElementWorldInterface");
static_assert(sizeof(USMInstanceElementWorldInterface) == 0x000030, "Wrong size on USMInstanceElementWorldInterface");

// Class Engine.DistributionVectorParameterBase
// 0x0070 (0x00C8 - 0x0058)
class UDistributionVectorParameterBase : public UDistributionVectorConstant
{
public:
	class FName                                   ParameterName;                                     // 0x0058(0x0008)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector                                MinInput;                                          // 0x0060(0x0018)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector                                MaxInput;                                          // 0x0078(0x0018)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector                                MinOutput;                                         // 0x0090(0x0018)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector                                MaxOutput;                                         // 0x00A8(0x0018)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EDistributionParamMode                        ParamModes[0x3];                                   // 0x00C0(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_C3[0x5];                                       // 0x00C3(0x0005)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"DistributionVectorParameterBase">();
	}
	static class UDistributionVectorParameterBase* GetDefaultObj()
	{
		return GetDefaultObjImpl<UDistributionVectorParameterBase>();
	}
};
static_assert(alignof(UDistributionVectorParameterBase) == 0x000008, "Wrong alignment on UDistributionVectorParameterBase");
static_assert(sizeof(UDistributionVectorParameterBase) == 0x0000C8, "Wrong size on UDistributionVectorParameterBase");
static_assert(offsetof(UDistributionVectorParameterBase, ParameterName) == 0x000058, "Member 'UDistributionVectorParameterBase::ParameterName' has a wrong offset!");
static_assert(offsetof(UDistributionVectorParameterBase, MinInput) == 0x000060, "Member 'UDistributionVectorParameterBase::MinInput' has a wrong offset!");
static_assert(offsetof(UDistributionVectorParameterBase, MaxInput) == 0x000078, "Member 'UDistributionVectorParameterBase::MaxInput' has a wrong offset!");
static_assert(offsetof(UDistributionVectorParameterBase, MinOutput) == 0x000090, "Member 'UDistributionVectorParameterBase::MinOutput' has a wrong offset!");
static_assert(offsetof(UDistributionVectorParameterBase, MaxOutput) == 0x0000A8, "Member 'UDistributionVectorParameterBase::MaxOutput' has a wrong offset!");
static_assert(offsetof(UDistributionVectorParameterBase, ParamModes) == 0x0000C0, "Member 'UDistributionVectorParameterBase::ParamModes' has a wrong offset!");

// Class Engine.AsyncActionLoadPrimaryAssetClassList
// 0x0010 (0x0088 - 0x0078)
class UAsyncActionLoadPrimaryAssetClassList final : public UAsyncActionLoadPrimaryAssetBase
{
public:
	TMulticastInlineDelegate<void(const TArray<TSubclassOf<class UObject>>& Loaded)> Completed;      // 0x0078(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)

public:
	static class UAsyncActionLoadPrimaryAssetClassList* AsyncLoadPrimaryAssetClassList(class UObject* WorldContextObject, const TArray<struct FPrimaryAssetId>& PrimaryAssetList, const TArray<class FName>& LoadBundles);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AsyncActionLoadPrimaryAssetClassList">();
	}
	static class UAsyncActionLoadPrimaryAssetClassList* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAsyncActionLoadPrimaryAssetClassList>();
	}
};
static_assert(alignof(UAsyncActionLoadPrimaryAssetClassList) == 0x000008, "Wrong alignment on UAsyncActionLoadPrimaryAssetClassList");
static_assert(sizeof(UAsyncActionLoadPrimaryAssetClassList) == 0x000088, "Wrong size on UAsyncActionLoadPrimaryAssetClassList");
static_assert(offsetof(UAsyncActionLoadPrimaryAssetClassList, Completed) == 0x000078, "Member 'UAsyncActionLoadPrimaryAssetClassList::Completed' has a wrong offset!");

// Class Engine.SkinnedAsset
// 0x0008 (0x00D0 - 0x00C8)
class USkinnedAsset : public UStreamableRenderAsset
{
public:
	uint8                                         Pad_C8[0x8];                                       // 0x00C8(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	class USkeletalMeshSocket* FindSocket(class FName InSocketName) const;
	class USkeletalMeshSocket* FindSocketInfo(class FName InSocketName, struct FTransform* OutTransform, int32* OutBoneIndex, int32* OutIndex) const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"SkinnedAsset">();
	}
	static class USkinnedAsset* GetDefaultObj()
	{
		return GetDefaultObjImpl<USkinnedAsset>();
	}
};
static_assert(alignof(USkinnedAsset) == 0x000008, "Wrong alignment on USkinnedAsset");
static_assert(sizeof(USkinnedAsset) == 0x0000D0, "Wrong size on USkinnedAsset");

// Class Engine.MaterialExpressionDataDrivenShaderPlatformInfoSwitch
// 0x0068 (0x0118 - 0x00B0)
class UMaterialExpressionDataDrivenShaderPlatformInfoSwitch final : public UMaterialExpression
{
public:
	struct FExpressionInput                       InputTrue;                                         // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       InputFalse;                                        // 0x00D8(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	TArray<struct FDataDrivenShaderPlatformInfoInput> DDSPIPropertyNames;                            // 0x0100(0x0010)(Edit, ZeroConstructor, NativeAccessSpecifierPublic)
	uint8                                         bContainsInvalidProperty : 1;                      // 0x0110(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_111[0x7];                                      // 0x0111(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	TArray<class FString> GetNameOptions() const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionDataDrivenShaderPlatformInfoSwitch">();
	}
	static class UMaterialExpressionDataDrivenShaderPlatformInfoSwitch* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionDataDrivenShaderPlatformInfoSwitch>();
	}
};
static_assert(alignof(UMaterialExpressionDataDrivenShaderPlatformInfoSwitch) == 0x000008, "Wrong alignment on UMaterialExpressionDataDrivenShaderPlatformInfoSwitch");
static_assert(sizeof(UMaterialExpressionDataDrivenShaderPlatformInfoSwitch) == 0x000118, "Wrong size on UMaterialExpressionDataDrivenShaderPlatformInfoSwitch");
static_assert(offsetof(UMaterialExpressionDataDrivenShaderPlatformInfoSwitch, InputTrue) == 0x0000B0, "Member 'UMaterialExpressionDataDrivenShaderPlatformInfoSwitch::InputTrue' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionDataDrivenShaderPlatformInfoSwitch, InputFalse) == 0x0000D8, "Member 'UMaterialExpressionDataDrivenShaderPlatformInfoSwitch::InputFalse' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionDataDrivenShaderPlatformInfoSwitch, DDSPIPropertyNames) == 0x000100, "Member 'UMaterialExpressionDataDrivenShaderPlatformInfoSwitch::DDSPIPropertyNames' has a wrong offset!");

// Class Engine.DistributionVectorParticleParameter
// 0x0000 (0x00C8 - 0x00C8)
class UDistributionVectorParticleParameter final : public UDistributionVectorParameterBase
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"DistributionVectorParticleParameter">();
	}
	static class UDistributionVectorParticleParameter* GetDefaultObj()
	{
		return GetDefaultObjImpl<UDistributionVectorParticleParameter>();
	}
};
static_assert(alignof(UDistributionVectorParticleParameter) == 0x000008, "Wrong alignment on UDistributionVectorParticleParameter");
static_assert(sizeof(UDistributionVectorParticleParameter) == 0x0000C8, "Wrong size on UDistributionVectorParticleParameter");

// Class Engine.DistributionVectorUniform
// 0x0040 (0x0078 - 0x0038)
class UDistributionVectorUniform final : public UDistributionVector
{
public:
	struct FVector                                Max;                                               // 0x0038(0x0018)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector                                Min;                                               // 0x0050(0x0018)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bLockAxes : 1;                                     // 0x0068(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_69[0x3];                                       // 0x0069(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	EDistributionVectorLockFlags                  LockedAxes;                                        // 0x006C(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EDistributionVectorMirrorFlags                MirrorFlags[0x3];                                  // 0x006D(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bUseExtremes : 1;                                  // 0x0070(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_71[0x7];                                       // 0x0071(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"DistributionVectorUniform">();
	}
	static class UDistributionVectorUniform* GetDefaultObj()
	{
		return GetDefaultObjImpl<UDistributionVectorUniform>();
	}
};
static_assert(alignof(UDistributionVectorUniform) == 0x000008, "Wrong alignment on UDistributionVectorUniform");
static_assert(sizeof(UDistributionVectorUniform) == 0x000078, "Wrong size on UDistributionVectorUniform");
static_assert(offsetof(UDistributionVectorUniform, Max) == 0x000038, "Member 'UDistributionVectorUniform::Max' has a wrong offset!");
static_assert(offsetof(UDistributionVectorUniform, Min) == 0x000050, "Member 'UDistributionVectorUniform::Min' has a wrong offset!");
static_assert(offsetof(UDistributionVectorUniform, LockedAxes) == 0x00006C, "Member 'UDistributionVectorUniform::LockedAxes' has a wrong offset!");
static_assert(offsetof(UDistributionVectorUniform, MirrorFlags) == 0x00006D, "Member 'UDistributionVectorUniform::MirrorFlags' has a wrong offset!");

// Class Engine.AnimBoneCompressionCodec
// 0x0010 (0x0038 - 0x0028)
class UAnimBoneCompressionCodec : public UObject
{
public:
	class FString                                 Description;                                       // 0x0028(0x0010)(Edit, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AnimBoneCompressionCodec">();
	}
	static class UAnimBoneCompressionCodec* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAnimBoneCompressionCodec>();
	}
};
static_assert(alignof(UAnimBoneCompressionCodec) == 0x000008, "Wrong alignment on UAnimBoneCompressionCodec");
static_assert(sizeof(UAnimBoneCompressionCodec) == 0x000038, "Wrong size on UAnimBoneCompressionCodec");
static_assert(offsetof(UAnimBoneCompressionCodec, Description) == 0x000028, "Member 'UAnimBoneCompressionCodec::Description' has a wrong offset!");

// Class Engine.AnimCompress
// 0x0008 (0x0040 - 0x0038)
class UAnimCompress : public UAnimBoneCompressionCodec
{
public:
	uint8                                         bNeedsSkeleton : 1;                                // 0x0038(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_39[0x3];                                       // 0x0039(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	EAnimationCompressionFormat                   TranslationCompressionFormat;                      // 0x003C(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EAnimationCompressionFormat                   RotationCompressionFormat;                         // 0x003D(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EAnimationCompressionFormat                   ScaleCompressionFormat;                            // 0x003E(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_3F[0x1];                                       // 0x003F(0x0001)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AnimCompress">();
	}
	static class UAnimCompress* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAnimCompress>();
	}
};
static_assert(alignof(UAnimCompress) == 0x000008, "Wrong alignment on UAnimCompress");
static_assert(sizeof(UAnimCompress) == 0x000040, "Wrong size on UAnimCompress");
static_assert(offsetof(UAnimCompress, TranslationCompressionFormat) == 0x00003C, "Member 'UAnimCompress::TranslationCompressionFormat' has a wrong offset!");
static_assert(offsetof(UAnimCompress, RotationCompressionFormat) == 0x00003D, "Member 'UAnimCompress::RotationCompressionFormat' has a wrong offset!");
static_assert(offsetof(UAnimCompress, ScaleCompressionFormat) == 0x00003E, "Member 'UAnimCompress::ScaleCompressionFormat' has a wrong offset!");

// Class Engine.AnimCompress_BitwiseCompressOnly
// 0x0000 (0x0040 - 0x0040)
class UAnimCompress_BitwiseCompressOnly : public UAnimCompress
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AnimCompress_BitwiseCompressOnly">();
	}
	static class UAnimCompress_BitwiseCompressOnly* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAnimCompress_BitwiseCompressOnly>();
	}
};
static_assert(alignof(UAnimCompress_BitwiseCompressOnly) == 0x000008, "Wrong alignment on UAnimCompress_BitwiseCompressOnly");
static_assert(sizeof(UAnimCompress_BitwiseCompressOnly) == 0x000040, "Wrong size on UAnimCompress_BitwiseCompressOnly");

// Class Engine.AnimCompress_LeastDestructive
// 0x0000 (0x0040 - 0x0040)
class UAnimCompress_LeastDestructive final : public UAnimCompress_BitwiseCompressOnly
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AnimCompress_LeastDestructive">();
	}
	static class UAnimCompress_LeastDestructive* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAnimCompress_LeastDestructive>();
	}
};
static_assert(alignof(UAnimCompress_LeastDestructive) == 0x000008, "Wrong alignment on UAnimCompress_LeastDestructive");
static_assert(sizeof(UAnimCompress_LeastDestructive) == 0x000040, "Wrong size on UAnimCompress_LeastDestructive");

// Class Engine.MaterialExpressionBlendMaterialAttributes
// 0x0090 (0x0140 - 0x00B0)
class UMaterialExpressionBlendMaterialAttributes final : public UMaterialExpression
{
public:
	struct FMaterialAttributesInput               A;                                                 // 0x00B0(0x0030)(NoDestructor, NativeAccessSpecifierPublic)
	struct FMaterialAttributesInput               B;                                                 // 0x00E0(0x0030)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       Alpha;                                             // 0x0110(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	EMaterialAttributeBlend                       PixelAttributeBlendType;                           // 0x0138(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EMaterialAttributeBlend                       VertexAttributeBlendType;                          // 0x0139(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_13A[0x6];                                      // 0x013A(0x0006)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionBlendMaterialAttributes">();
	}
	static class UMaterialExpressionBlendMaterialAttributes* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionBlendMaterialAttributes>();
	}
};
static_assert(alignof(UMaterialExpressionBlendMaterialAttributes) == 0x000008, "Wrong alignment on UMaterialExpressionBlendMaterialAttributes");
static_assert(sizeof(UMaterialExpressionBlendMaterialAttributes) == 0x000140, "Wrong size on UMaterialExpressionBlendMaterialAttributes");
static_assert(offsetof(UMaterialExpressionBlendMaterialAttributes, A) == 0x0000B0, "Member 'UMaterialExpressionBlendMaterialAttributes::A' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionBlendMaterialAttributes, B) == 0x0000E0, "Member 'UMaterialExpressionBlendMaterialAttributes::B' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionBlendMaterialAttributes, Alpha) == 0x000110, "Member 'UMaterialExpressionBlendMaterialAttributes::Alpha' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionBlendMaterialAttributes, PixelAttributeBlendType) == 0x000138, "Member 'UMaterialExpressionBlendMaterialAttributes::PixelAttributeBlendType' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionBlendMaterialAttributes, VertexAttributeBlendType) == 0x000139, "Member 'UMaterialExpressionBlendMaterialAttributes::VertexAttributeBlendType' has a wrong offset!");

// Class Engine.DistributionVectorUniformCurve
// 0x0028 (0x0060 - 0x0038)
class UDistributionVectorUniformCurve final : public UDistributionVector
{
public:
	struct FInterpCurveTwoVectors                 ConstantCurve;                                     // 0x0038(0x0018)(Edit, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bLockAxes1 : 1;                                    // 0x0050(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bLockAxes2 : 1;                                    // 0x0050(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_51[0x3];                                       // 0x0051(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	EDistributionVectorLockFlags                  LockedAxes[0x2];                                   // 0x0054(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EDistributionVectorMirrorFlags                MirrorFlags[0x3];                                  // 0x0056(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_59[0x3];                                       // 0x0059(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	uint8                                         bUseExtremes : 1;                                  // 0x005C(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_5D[0x3];                                       // 0x005D(0x0003)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"DistributionVectorUniformCurve">();
	}
	static class UDistributionVectorUniformCurve* GetDefaultObj()
	{
		return GetDefaultObjImpl<UDistributionVectorUniformCurve>();
	}
};
static_assert(alignof(UDistributionVectorUniformCurve) == 0x000008, "Wrong alignment on UDistributionVectorUniformCurve");
static_assert(sizeof(UDistributionVectorUniformCurve) == 0x000060, "Wrong size on UDistributionVectorUniformCurve");
static_assert(offsetof(UDistributionVectorUniformCurve, ConstantCurve) == 0x000038, "Member 'UDistributionVectorUniformCurve::ConstantCurve' has a wrong offset!");
static_assert(offsetof(UDistributionVectorUniformCurve, LockedAxes) == 0x000054, "Member 'UDistributionVectorUniformCurve::LockedAxes' has a wrong offset!");
static_assert(offsetof(UDistributionVectorUniformCurve, MirrorFlags) == 0x000056, "Member 'UDistributionVectorUniformCurve::MirrorFlags' has a wrong offset!");

// Class Engine.GraphNodeContextMenuContext
// 0x0028 (0x0050 - 0x0028)
class UGraphNodeContextMenuContext final : public UObject
{
public:
	class UBlueprint*                             Blueprint;                                         // 0x0028(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UEdGraph*                               Graph;                                             // 0x0030(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UEdGraphNode*                           Node;                                              // 0x0038(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_40[0x8];                                       // 0x0040(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	bool                                          bIsDebugging;                                      // 0x0048(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_49[0x7];                                       // 0x0049(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"GraphNodeContextMenuContext">();
	}
	static class UGraphNodeContextMenuContext* GetDefaultObj()
	{
		return GetDefaultObjImpl<UGraphNodeContextMenuContext>();
	}
};
static_assert(alignof(UGraphNodeContextMenuContext) == 0x000008, "Wrong alignment on UGraphNodeContextMenuContext");
static_assert(sizeof(UGraphNodeContextMenuContext) == 0x000050, "Wrong size on UGraphNodeContextMenuContext");
static_assert(offsetof(UGraphNodeContextMenuContext, Blueprint) == 0x000028, "Member 'UGraphNodeContextMenuContext::Blueprint' has a wrong offset!");
static_assert(offsetof(UGraphNodeContextMenuContext, Graph) == 0x000030, "Member 'UGraphNodeContextMenuContext::Graph' has a wrong offset!");
static_assert(offsetof(UGraphNodeContextMenuContext, Node) == 0x000038, "Member 'UGraphNodeContextMenuContext::Node' has a wrong offset!");
static_assert(offsetof(UGraphNodeContextMenuContext, bIsDebugging) == 0x000048, "Member 'UGraphNodeContextMenuContext::bIsDebugging' has a wrong offset!");

// Class Engine.ObjectTraceWorldSubsystem
// 0x0010 (0x0040 - 0x0030)
class UObjectTraceWorldSubsystem final : public UWorldSubsystem
{
public:
	uint8                                         Pad_30[0x10];                                      // 0x0030(0x0010)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ObjectTraceWorldSubsystem">();
	}
	static class UObjectTraceWorldSubsystem* GetDefaultObj()
	{
		return GetDefaultObjImpl<UObjectTraceWorldSubsystem>();
	}
};
static_assert(alignof(UObjectTraceWorldSubsystem) == 0x000008, "Wrong alignment on UObjectTraceWorldSubsystem");
static_assert(sizeof(UObjectTraceWorldSubsystem) == 0x000040, "Wrong size on UObjectTraceWorldSubsystem");

// Class Engine.MaterialExpressionDesaturation
// 0x0060 (0x0110 - 0x00B0)
class UMaterialExpressionDesaturation final : public UMaterialExpression
{
public:
	struct FExpressionInput                       Input;                                             // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       Fraction;                                          // 0x00D8(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FLinearColor                           LuminanceFactors;                                  // 0x0100(0x0010)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionDesaturation">();
	}
	static class UMaterialExpressionDesaturation* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionDesaturation>();
	}
};
static_assert(alignof(UMaterialExpressionDesaturation) == 0x000008, "Wrong alignment on UMaterialExpressionDesaturation");
static_assert(sizeof(UMaterialExpressionDesaturation) == 0x000110, "Wrong size on UMaterialExpressionDesaturation");
static_assert(offsetof(UMaterialExpressionDesaturation, Input) == 0x0000B0, "Member 'UMaterialExpressionDesaturation::Input' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionDesaturation, Fraction) == 0x0000D8, "Member 'UMaterialExpressionDesaturation::Fraction' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionDesaturation, LuminanceFactors) == 0x000100, "Member 'UMaterialExpressionDesaturation::LuminanceFactors' has a wrong offset!");

// Class Engine.EdGraphPin_Deprecated
// 0x00F0 (0x0118 - 0x0028)
class UEdGraphPin_Deprecated final : public UObject
{
public:
	class FString                                 PinName;                                           // 0x0028(0x0010)(ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FString                                 PinToolTip;                                        // 0x0038(0x0010)(ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EEdGraphPinDirection                          Direction;                                         // 0x0048(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_49[0x7];                                       // 0x0049(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	struct FEdGraphPinType                        PinType;                                           // 0x0050(0x0058)(NoDestructor, NativeAccessSpecifierPublic)
	class FString                                 DefaultValue;                                      // 0x00A8(0x0010)(ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FString                                 AutogeneratedDefaultValue;                         // 0x00B8(0x0010)(ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UObject*                                DefaultObject;                                     // 0x00C8(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FText                                   DefaultTextValue;                                  // 0x00D0(0x0018)(NativeAccessSpecifierPublic)
	TArray<class UEdGraphPin_Deprecated*>         LinkedTo;                                          // 0x00E8(0x0010)(ZeroConstructor, UObjectWrapper, NativeAccessSpecifierPublic)
	TArray<class UEdGraphPin_Deprecated*>         SubPins;                                           // 0x00F8(0x0010)(ZeroConstructor, UObjectWrapper, NativeAccessSpecifierPublic)
	class UEdGraphPin_Deprecated*                 ParentPin;                                         // 0x0108(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UEdGraphPin_Deprecated*                 ReferencePassThroughConnection;                    // 0x0110(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"EdGraphPin_Deprecated">();
	}
	static class UEdGraphPin_Deprecated* GetDefaultObj()
	{
		return GetDefaultObjImpl<UEdGraphPin_Deprecated>();
	}
};
static_assert(alignof(UEdGraphPin_Deprecated) == 0x000008, "Wrong alignment on UEdGraphPin_Deprecated");
static_assert(sizeof(UEdGraphPin_Deprecated) == 0x000118, "Wrong size on UEdGraphPin_Deprecated");
static_assert(offsetof(UEdGraphPin_Deprecated, PinName) == 0x000028, "Member 'UEdGraphPin_Deprecated::PinName' has a wrong offset!");
static_assert(offsetof(UEdGraphPin_Deprecated, PinToolTip) == 0x000038, "Member 'UEdGraphPin_Deprecated::PinToolTip' has a wrong offset!");
static_assert(offsetof(UEdGraphPin_Deprecated, Direction) == 0x000048, "Member 'UEdGraphPin_Deprecated::Direction' has a wrong offset!");
static_assert(offsetof(UEdGraphPin_Deprecated, PinType) == 0x000050, "Member 'UEdGraphPin_Deprecated::PinType' has a wrong offset!");
static_assert(offsetof(UEdGraphPin_Deprecated, DefaultValue) == 0x0000A8, "Member 'UEdGraphPin_Deprecated::DefaultValue' has a wrong offset!");
static_assert(offsetof(UEdGraphPin_Deprecated, AutogeneratedDefaultValue) == 0x0000B8, "Member 'UEdGraphPin_Deprecated::AutogeneratedDefaultValue' has a wrong offset!");
static_assert(offsetof(UEdGraphPin_Deprecated, DefaultObject) == 0x0000C8, "Member 'UEdGraphPin_Deprecated::DefaultObject' has a wrong offset!");
static_assert(offsetof(UEdGraphPin_Deprecated, DefaultTextValue) == 0x0000D0, "Member 'UEdGraphPin_Deprecated::DefaultTextValue' has a wrong offset!");
static_assert(offsetof(UEdGraphPin_Deprecated, LinkedTo) == 0x0000E8, "Member 'UEdGraphPin_Deprecated::LinkedTo' has a wrong offset!");
static_assert(offsetof(UEdGraphPin_Deprecated, SubPins) == 0x0000F8, "Member 'UEdGraphPin_Deprecated::SubPins' has a wrong offset!");
static_assert(offsetof(UEdGraphPin_Deprecated, ParentPin) == 0x000108, "Member 'UEdGraphPin_Deprecated::ParentPin' has a wrong offset!");
static_assert(offsetof(UEdGraphPin_Deprecated, ReferencePassThroughConnection) == 0x000110, "Member 'UEdGraphPin_Deprecated::ReferencePassThroughConnection' has a wrong offset!");

// Class Engine.OnlineBlueprintCallProxyBase
// 0x0000 (0x0030 - 0x0030)
class UOnlineBlueprintCallProxyBase : public UBlueprintAsyncActionBase
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"OnlineBlueprintCallProxyBase">();
	}
	static class UOnlineBlueprintCallProxyBase* GetDefaultObj()
	{
		return GetDefaultObjImpl<UOnlineBlueprintCallProxyBase>();
	}
};
static_assert(alignof(UOnlineBlueprintCallProxyBase) == 0x000008, "Wrong alignment on UOnlineBlueprintCallProxyBase");
static_assert(sizeof(UOnlineBlueprintCallProxyBase) == 0x000030, "Wrong size on UOnlineBlueprintCallProxyBase");

// Class Engine.MaterialExpressionStrataVolumetricFogCloudBSDF
// 0x00A0 (0x0150 - 0x00B0)
class UMaterialExpressionStrataVolumetricFogCloudBSDF final : public UMaterialExpressionStrataBSDF
{
public:
	struct FExpressionInput                       Albedo;                                            // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       Extinction;                                        // 0x00D8(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       EmissiveColor;                                     // 0x0100(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       AmbientOcclusion;                                  // 0x0128(0x0028)(NoDestructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionStrataVolumetricFogCloudBSDF">();
	}
	static class UMaterialExpressionStrataVolumetricFogCloudBSDF* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionStrataVolumetricFogCloudBSDF>();
	}
};
static_assert(alignof(UMaterialExpressionStrataVolumetricFogCloudBSDF) == 0x000008, "Wrong alignment on UMaterialExpressionStrataVolumetricFogCloudBSDF");
static_assert(sizeof(UMaterialExpressionStrataVolumetricFogCloudBSDF) == 0x000150, "Wrong size on UMaterialExpressionStrataVolumetricFogCloudBSDF");
static_assert(offsetof(UMaterialExpressionStrataVolumetricFogCloudBSDF, Albedo) == 0x0000B0, "Member 'UMaterialExpressionStrataVolumetricFogCloudBSDF::Albedo' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionStrataVolumetricFogCloudBSDF, Extinction) == 0x0000D8, "Member 'UMaterialExpressionStrataVolumetricFogCloudBSDF::Extinction' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionStrataVolumetricFogCloudBSDF, EmissiveColor) == 0x000100, "Member 'UMaterialExpressionStrataVolumetricFogCloudBSDF::EmissiveColor' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionStrataVolumetricFogCloudBSDF, AmbientOcclusion) == 0x000128, "Member 'UMaterialExpressionStrataVolumetricFogCloudBSDF::AmbientOcclusion' has a wrong offset!");

// Class Engine.EdGraphSchema
// 0x0000 (0x0028 - 0x0028)
class UEdGraphSchema final : public UObject
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"EdGraphSchema">();
	}
	static class UEdGraphSchema* GetDefaultObj()
	{
		return GetDefaultObjImpl<UEdGraphSchema>();
	}
};
static_assert(alignof(UEdGraphSchema) == 0x000008, "Wrong alignment on UEdGraphSchema");
static_assert(sizeof(UEdGraphSchema) == 0x000028, "Wrong size on UEdGraphSchema");

// Class Engine.Emitter
// 0x0050 (0x02F0 - 0x02A0)
class AEmitter : public AActor
{
public:
	class UParticleSystemComponent*               ParticleSystemComponent;                           // 0x02A0(0x0008)(Edit, BlueprintVisible, ExportObject, BlueprintReadOnly, ZeroConstructor, EditConst, InstancedReference, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         bDestroyOnSystemFinish : 1;                        // 0x02A8(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bPostUpdateTickGroup : 1;                          // 0x02A8(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bCurrentlyActive : 1;                              // 0x02A8(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Net, RepNotify, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_2A9[0x7];                                      // 0x02A9(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	TMulticastInlineDelegate<void(class FName EventName, float EmitterTime, const struct FVector& Location, const struct FVector& Velocity)> OnParticleSpawn; // 0x02B0(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	TMulticastInlineDelegate<void(class FName EventName, float EmitterTime, int32 ParticleCount)> OnParticleBurst; // 0x02C0(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	TMulticastInlineDelegate<void(class FName EventName, float EmitterTime, int32 ParticleTime, const struct FVector& Location, const struct FVector& Velocity, const struct FVector& Direction)> OnParticleDeath; // 0x02D0(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	TMulticastInlineDelegate<void(class FName EventName, float EmitterTime, int32 ParticleTime, const struct FVector& Location, const struct FVector& Velocity, const struct FVector& Direction, const struct FVector& Normal, class FName BoneName, class UPhysicalMaterial* PhysMat)> OnParticleCollide; // 0x02E0(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)

public:
	void Activate();
	void Deactivate();
	void OnParticleSystemFinished(class UParticleSystemComponent* FinishedComponent);
	void OnRep_bCurrentlyActive();
	void SetActorParameter(class FName ParameterName, class AActor* Param);
	void SetColorParameter(class FName ParameterName, const struct FLinearColor& Param);
	void SetFloatParameter(class FName ParameterName, float Param);
	void SetMaterialParameter(class FName ParameterName, class UMaterialInterface* Param);
	void SetTemplate(class UParticleSystem* NewTemplate);
	void SetVectorParameter(class FName ParameterName, const struct FVector& Param);
	void ToggleActive();

	bool IsActive() const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"Emitter">();
	}
	static class AEmitter* GetDefaultObj()
	{
		return GetDefaultObjImpl<AEmitter>();
	}
};
static_assert(alignof(AEmitter) == 0x000008, "Wrong alignment on AEmitter");
static_assert(sizeof(AEmitter) == 0x0002F0, "Wrong size on AEmitter");
static_assert(offsetof(AEmitter, ParticleSystemComponent) == 0x0002A0, "Member 'AEmitter::ParticleSystemComponent' has a wrong offset!");
static_assert(offsetof(AEmitter, OnParticleSpawn) == 0x0002B0, "Member 'AEmitter::OnParticleSpawn' has a wrong offset!");
static_assert(offsetof(AEmitter, OnParticleBurst) == 0x0002C0, "Member 'AEmitter::OnParticleBurst' has a wrong offset!");
static_assert(offsetof(AEmitter, OnParticleDeath) == 0x0002D0, "Member 'AEmitter::OnParticleDeath' has a wrong offset!");
static_assert(offsetof(AEmitter, OnParticleCollide) == 0x0002E0, "Member 'AEmitter::OnParticleCollide' has a wrong offset!");

// Class Engine.EmitterCameraLensEffectBase
// 0x00A0 (0x0390 - 0x02F0)
class AEmitterCameraLensEffectBase final : public AEmitter
{
public:
	uint8                                         Pad_2F0[0x8];                                      // 0x02F0(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	class UParticleSystem*                        PS_CameraEffect;                                   // 0x02F8(0x0008)(Edit, ZeroConstructor, DisableEditOnInstance, NoDestructor, Protected, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	class APlayerCameraManager*                   BaseCamera;                                        // 0x0300(0x0008)(ZeroConstructor, Transient, NoDestructor, Protected, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_308[0x8];                                      // 0x0308(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	struct FTransform                             RelativeTransform;                                 // 0x0310(0x0060)(Edit, DisableEditOnInstance, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	float                                         BaseFOV;                                           // 0x0370(0x0004)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bAllowMultipleInstances : 1;                       // 0x0374(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bResetWhenRetriggered : 1;                         // 0x0374(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_375[0x3];                                      // 0x0375(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<TSubclassOf<class AActor>>             EmittersToTreatAsSame;                             // 0x0378(0x0010)(Edit, ZeroConstructor, DisableEditOnInstance, UObjectWrapper, NativeAccessSpecifierPublic)
	float                                         DistFromCamera;                                    // 0x0388(0x0004)(ZeroConstructor, Deprecated, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_38C[0x4];                                      // 0x038C(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"EmitterCameraLensEffectBase">();
	}
	static class AEmitterCameraLensEffectBase* GetDefaultObj()
	{
		return GetDefaultObjImpl<AEmitterCameraLensEffectBase>();
	}
};
static_assert(alignof(AEmitterCameraLensEffectBase) == 0x000010, "Wrong alignment on AEmitterCameraLensEffectBase");
static_assert(sizeof(AEmitterCameraLensEffectBase) == 0x000390, "Wrong size on AEmitterCameraLensEffectBase");
static_assert(offsetof(AEmitterCameraLensEffectBase, PS_CameraEffect) == 0x0002F8, "Member 'AEmitterCameraLensEffectBase::PS_CameraEffect' has a wrong offset!");
static_assert(offsetof(AEmitterCameraLensEffectBase, BaseCamera) == 0x000300, "Member 'AEmitterCameraLensEffectBase::BaseCamera' has a wrong offset!");
static_assert(offsetof(AEmitterCameraLensEffectBase, RelativeTransform) == 0x000310, "Member 'AEmitterCameraLensEffectBase::RelativeTransform' has a wrong offset!");
static_assert(offsetof(AEmitterCameraLensEffectBase, BaseFOV) == 0x000370, "Member 'AEmitterCameraLensEffectBase::BaseFOV' has a wrong offset!");
static_assert(offsetof(AEmitterCameraLensEffectBase, EmittersToTreatAsSame) == 0x000378, "Member 'AEmitterCameraLensEffectBase::EmittersToTreatAsSame' has a wrong offset!");
static_assert(offsetof(AEmitterCameraLensEffectBase, DistFromCamera) == 0x000388, "Member 'AEmitterCameraLensEffectBase::DistFromCamera' has a wrong offset!");

// Class Engine.SlateTextureAtlasInterface
// 0x0000 (0x0000 - 0x0000)
class ISlateTextureAtlasInterface final
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"SlateTextureAtlasInterface">();
	}
	static class ISlateTextureAtlasInterface* GetDefaultObj()
	{
		return GetDefaultObjImpl<ISlateTextureAtlasInterface>();
	}

	class UObject* AsUObject()
	{
		return reinterpret_cast<UObject*>(this);
	}
	const class UObject* AsUObject() const
	{
		return reinterpret_cast<const UObject*>(this);
	}
};
static_assert(alignof(ISlateTextureAtlasInterface) == 0x000001, "Wrong alignment on ISlateTextureAtlasInterface");
static_assert(sizeof(ISlateTextureAtlasInterface) == 0x000001, "Wrong size on ISlateTextureAtlasInterface");

// Class Engine.MaterialExpressionNaniteReplace
// 0x0050 (0x0100 - 0x00B0)
class UMaterialExpressionNaniteReplace final : public UMaterialExpression
{
public:
	struct FExpressionInput                       Default;                                           // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       Nanite;                                            // 0x00D8(0x0028)(NoDestructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionNaniteReplace">();
	}
	static class UMaterialExpressionNaniteReplace* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionNaniteReplace>();
	}
};
static_assert(alignof(UMaterialExpressionNaniteReplace) == 0x000008, "Wrong alignment on UMaterialExpressionNaniteReplace");
static_assert(sizeof(UMaterialExpressionNaniteReplace) == 0x000100, "Wrong size on UMaterialExpressionNaniteReplace");
static_assert(offsetof(UMaterialExpressionNaniteReplace, Default) == 0x0000B0, "Member 'UMaterialExpressionNaniteReplace::Default' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionNaniteReplace, Nanite) == 0x0000D8, "Member 'UMaterialExpressionNaniteReplace::Nanite' has a wrong offset!");

// Class Engine.ViewModeUtils
// 0x0000 (0x0028 - 0x0028)
class UViewModeUtils final : public UObject
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ViewModeUtils">();
	}
	static class UViewModeUtils* GetDefaultObj()
	{
		return GetDefaultObjImpl<UViewModeUtils>();
	}
};
static_assert(alignof(UViewModeUtils) == 0x000008, "Wrong alignment on UViewModeUtils");
static_assert(sizeof(UViewModeUtils) == 0x000028, "Wrong size on UViewModeUtils");

// Class Engine.AnimCurveCompressionCodec
// 0x0010 (0x0038 - 0x0028)
class UAnimCurveCompressionCodec : public UObject
{
public:
	uint8                                         Pad_28[0x10];                                      // 0x0028(0x0010)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AnimCurveCompressionCodec">();
	}
	static class UAnimCurveCompressionCodec* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAnimCurveCompressionCodec>();
	}
};
static_assert(alignof(UAnimCurveCompressionCodec) == 0x000008, "Wrong alignment on UAnimCurveCompressionCodec");
static_assert(sizeof(UAnimCurveCompressionCodec) == 0x000038, "Wrong size on UAnimCurveCompressionCodec");

// Class Engine.AnimCurveCompressionCodec_UniformlySampled
// 0x0000 (0x0038 - 0x0038)
class UAnimCurveCompressionCodec_UniformlySampled final : public UAnimCurveCompressionCodec
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AnimCurveCompressionCodec_UniformlySampled">();
	}
	static class UAnimCurveCompressionCodec_UniformlySampled* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAnimCurveCompressionCodec_UniformlySampled>();
	}
};
static_assert(alignof(UAnimCurveCompressionCodec_UniformlySampled) == 0x000008, "Wrong alignment on UAnimCurveCompressionCodec_UniformlySampled");
static_assert(sizeof(UAnimCurveCompressionCodec_UniformlySampled) == 0x000038, "Wrong size on UAnimCurveCompressionCodec_UniformlySampled");

// Class Engine.MaterialExpressionVectorParameter
// 0x0078 (0x0150 - 0x00D8)
class UMaterialExpressionVectorParameter : public UMaterialExpressionParameter
{
public:
	struct FLinearColor                           DefaultValue;                                      // 0x00D8(0x0010)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bUseCustomPrimitiveData;                           // 0x00E8(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         PrimitiveDataIndex;                                // 0x00E9(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_EA[0x6];                                       // 0x00EA(0x0006)(Fixing Size After Last Property [ Dumper-7 ])
	struct FParameterChannelNames                 ChannelNames;                                      // 0x00F0(0x0060)(Edit, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionVectorParameter">();
	}
	static class UMaterialExpressionVectorParameter* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionVectorParameter>();
	}
};
static_assert(alignof(UMaterialExpressionVectorParameter) == 0x000008, "Wrong alignment on UMaterialExpressionVectorParameter");
static_assert(sizeof(UMaterialExpressionVectorParameter) == 0x000150, "Wrong size on UMaterialExpressionVectorParameter");
static_assert(offsetof(UMaterialExpressionVectorParameter, DefaultValue) == 0x0000D8, "Member 'UMaterialExpressionVectorParameter::DefaultValue' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionVectorParameter, bUseCustomPrimitiveData) == 0x0000E8, "Member 'UMaterialExpressionVectorParameter::bUseCustomPrimitiveData' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionVectorParameter, PrimitiveDataIndex) == 0x0000E9, "Member 'UMaterialExpressionVectorParameter::PrimitiveDataIndex' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionVectorParameter, ChannelNames) == 0x0000F0, "Member 'UMaterialExpressionVectorParameter::ChannelNames' has a wrong offset!");

// Class Engine.MaterialExpressionChannelMaskParameter
// 0x0030 (0x0180 - 0x0150)
class UMaterialExpressionChannelMaskParameter final : public UMaterialExpressionVectorParameter
{
public:
	EChannelMaskParameterColor                    MaskChannel;                                       // 0x0150(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_151[0x7];                                      // 0x0151(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	struct FExpressionInput                       Input;                                             // 0x0158(0x0028)(NoDestructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionChannelMaskParameter">();
	}
	static class UMaterialExpressionChannelMaskParameter* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionChannelMaskParameter>();
	}
};
static_assert(alignof(UMaterialExpressionChannelMaskParameter) == 0x000008, "Wrong alignment on UMaterialExpressionChannelMaskParameter");
static_assert(sizeof(UMaterialExpressionChannelMaskParameter) == 0x000180, "Wrong size on UMaterialExpressionChannelMaskParameter");
static_assert(offsetof(UMaterialExpressionChannelMaskParameter, MaskChannel) == 0x000150, "Member 'UMaterialExpressionChannelMaskParameter::MaskChannel' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionChannelMaskParameter, Input) == 0x000158, "Member 'UMaterialExpressionChannelMaskParameter::Input' has a wrong offset!");

// Class Engine.EngineBaseTypes
// 0x0000 (0x0028 - 0x0028)
class UEngineBaseTypes final : public UObject
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"EngineBaseTypes">();
	}
	static class UEngineBaseTypes* GetDefaultObj()
	{
		return GetDefaultObjImpl<UEngineBaseTypes>();
	}
};
static_assert(alignof(UEngineBaseTypes) == 0x000008, "Wrong alignment on UEngineBaseTypes");
static_assert(sizeof(UEngineBaseTypes) == 0x000028, "Wrong size on UEngineBaseTypes");

// Class Engine.AnimSet
// 0x00C8 (0x00F0 - 0x0028)
class UAnimSet final : public UObject
{
public:
	uint8                                         bAnimRotationOnly : 1;                             // 0x0028(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate))
	uint8                                         Pad_29[0x7];                                       // 0x0029(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<class FName>                           TrackBoneNames;                                    // 0x0030(0x0010)(ZeroConstructor, NativeAccessSpecifierPublic)
	TArray<struct FAnimSetMeshLinkup>             LinkupCache;                                       // 0x0040(0x0010)(ZeroConstructor, Transient, NativeAccessSpecifierPrivate)
	TArray<uint8>                                 BoneUseAnimTranslation;                            // 0x0050(0x0010)(ZeroConstructor, Transient, NativeAccessSpecifierPrivate)
	TArray<uint8>                                 ForceUseMeshTranslation;                           // 0x0060(0x0010)(ZeroConstructor, Transient, NativeAccessSpecifierPrivate)
	TArray<class FName>                           UseTranslationBoneNames;                           // 0x0070(0x0010)(Edit, ZeroConstructor, NativeAccessSpecifierPrivate)
	TArray<class FName>                           ForceMeshTranslationBoneNames;                     // 0x0080(0x0010)(Edit, ZeroConstructor, NativeAccessSpecifierPrivate)
	class FName                                   PreviewSkelMeshName;                               // 0x0090(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FName                                   BestRatioSkelMeshName;                             // 0x0098(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_A0[0x50];                                      // 0x00A0(0x0050)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AnimSet">();
	}
	static class UAnimSet* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAnimSet>();
	}
};
static_assert(alignof(UAnimSet) == 0x000008, "Wrong alignment on UAnimSet");
static_assert(sizeof(UAnimSet) == 0x0000F0, "Wrong size on UAnimSet");
static_assert(offsetof(UAnimSet, TrackBoneNames) == 0x000030, "Member 'UAnimSet::TrackBoneNames' has a wrong offset!");
static_assert(offsetof(UAnimSet, LinkupCache) == 0x000040, "Member 'UAnimSet::LinkupCache' has a wrong offset!");
static_assert(offsetof(UAnimSet, BoneUseAnimTranslation) == 0x000050, "Member 'UAnimSet::BoneUseAnimTranslation' has a wrong offset!");
static_assert(offsetof(UAnimSet, ForceUseMeshTranslation) == 0x000060, "Member 'UAnimSet::ForceUseMeshTranslation' has a wrong offset!");
static_assert(offsetof(UAnimSet, UseTranslationBoneNames) == 0x000070, "Member 'UAnimSet::UseTranslationBoneNames' has a wrong offset!");
static_assert(offsetof(UAnimSet, ForceMeshTranslationBoneNames) == 0x000080, "Member 'UAnimSet::ForceMeshTranslationBoneNames' has a wrong offset!");
static_assert(offsetof(UAnimSet, PreviewSkelMeshName) == 0x000090, "Member 'UAnimSet::PreviewSkelMeshName' has a wrong offset!");
static_assert(offsetof(UAnimSet, BestRatioSkelMeshName) == 0x000098, "Member 'UAnimSet::BestRatioSkelMeshName' has a wrong offset!");

// Class Engine.EngineTypes
// 0x0000 (0x0028 - 0x0028)
class UEngineTypes final : public UObject
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"EngineTypes">();
	}
	static class UEngineTypes* GetDefaultObj()
	{
		return GetDefaultObjImpl<UEngineTypes>();
	}
};
static_assert(alignof(UEngineTypes) == 0x000008, "Wrong alignment on UEngineTypes");
static_assert(sizeof(UEngineTypes) == 0x000028, "Wrong size on UEngineTypes");

// Class Engine.SoundNodeDoppler
// 0x0010 (0x0058 - 0x0048)
class USoundNodeDoppler final : public USoundNode
{
public:
	float                                         DopplerIntensity;                                  // 0x0048(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bUseSmoothing;                                     // 0x004C(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_4D[0x3];                                       // 0x004D(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         SmoothingInterpSpeed;                              // 0x0050(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_54[0x4];                                       // 0x0054(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"SoundNodeDoppler">();
	}
	static class USoundNodeDoppler* GetDefaultObj()
	{
		return GetDefaultObjImpl<USoundNodeDoppler>();
	}
};
static_assert(alignof(USoundNodeDoppler) == 0x000008, "Wrong alignment on USoundNodeDoppler");
static_assert(sizeof(USoundNodeDoppler) == 0x000058, "Wrong size on USoundNodeDoppler");
static_assert(offsetof(USoundNodeDoppler, DopplerIntensity) == 0x000048, "Member 'USoundNodeDoppler::DopplerIntensity' has a wrong offset!");
static_assert(offsetof(USoundNodeDoppler, bUseSmoothing) == 0x00004C, "Member 'USoundNodeDoppler::bUseSmoothing' has a wrong offset!");
static_assert(offsetof(USoundNodeDoppler, SmoothingInterpSpeed) == 0x000050, "Member 'USoundNodeDoppler::SmoothingInterpSpeed' has a wrong offset!");

// Class Engine.MaterialExpressionDotProduct
// 0x0050 (0x0100 - 0x00B0)
class UMaterialExpressionDotProduct final : public UMaterialExpression
{
public:
	struct FExpressionInput                       A;                                                 // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       B;                                                 // 0x00D8(0x0028)(NoDestructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionDotProduct">();
	}
	static class UMaterialExpressionDotProduct* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionDotProduct>();
	}
};
static_assert(alignof(UMaterialExpressionDotProduct) == 0x000008, "Wrong alignment on UMaterialExpressionDotProduct");
static_assert(sizeof(UMaterialExpressionDotProduct) == 0x000100, "Wrong size on UMaterialExpressionDotProduct");
static_assert(offsetof(UMaterialExpressionDotProduct, A) == 0x0000B0, "Member 'UMaterialExpressionDotProduct::A' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionDotProduct, B) == 0x0000D8, "Member 'UMaterialExpressionDotProduct::B' has a wrong offset!");

// Class Engine.ExponentialHeightFog
// 0x0010 (0x02B0 - 0x02A0)
class AExponentialHeightFog final : public AInfo
{
public:
	class UExponentialHeightFogComponent*         Component;                                         // 0x02A0(0x0008)(Edit, BlueprintVisible, ExportObject, BlueprintReadOnly, ZeroConstructor, EditConst, InstancedReference, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         bEnabled : 1;                                      // 0x02A8(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Net, RepNotify, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_2A9[0x7];                                      // 0x02A9(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void OnRep_bEnabled();

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ExponentialHeightFog">();
	}
	static class AExponentialHeightFog* GetDefaultObj()
	{
		return GetDefaultObjImpl<AExponentialHeightFog>();
	}
};
static_assert(alignof(AExponentialHeightFog) == 0x000008, "Wrong alignment on AExponentialHeightFog");
static_assert(sizeof(AExponentialHeightFog) == 0x0002B0, "Wrong size on AExponentialHeightFog");
static_assert(offsetof(AExponentialHeightFog, Component) == 0x0002A0, "Member 'AExponentialHeightFog::Component' has a wrong offset!");

// Class Engine.SoundNodeEnveloper
// 0x0148 (0x0190 - 0x0048)
class USoundNodeEnveloper final : public USoundNode
{
public:
	float                                         LoopStart;                                         // 0x0048(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         LoopEnd;                                           // 0x004C(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         DurationAfterLoop;                                 // 0x0050(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         LoopCount;                                         // 0x0054(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bLoopIndefinitely : 1;                             // 0x0058(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bLoop : 1;                                         // 0x0058(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_59[0x7];                                       // 0x0059(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	class UDistributionFloatConstantCurve*        VolumeInterpCurve;                                 // 0x0060(0x0008)(ExportObject, ZeroConstructor, InstancedReference, Deprecated, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UDistributionFloatConstantCurve*        PitchInterpCurve;                                  // 0x0068(0x0008)(ExportObject, ZeroConstructor, InstancedReference, Deprecated, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FRuntimeFloatCurve                     VolumeCurve;                                       // 0x0070(0x0088)(Edit, NativeAccessSpecifierPublic)
	struct FRuntimeFloatCurve                     PitchCurve;                                        // 0x00F8(0x0088)(Edit, NativeAccessSpecifierPublic)
	float                                         PitchMin;                                          // 0x0180(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         PitchMax;                                          // 0x0184(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         VolumeMin;                                         // 0x0188(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         VolumeMax;                                         // 0x018C(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"SoundNodeEnveloper">();
	}
	static class USoundNodeEnveloper* GetDefaultObj()
	{
		return GetDefaultObjImpl<USoundNodeEnveloper>();
	}
};
static_assert(alignof(USoundNodeEnveloper) == 0x000008, "Wrong alignment on USoundNodeEnveloper");
static_assert(sizeof(USoundNodeEnveloper) == 0x000190, "Wrong size on USoundNodeEnveloper");
static_assert(offsetof(USoundNodeEnveloper, LoopStart) == 0x000048, "Member 'USoundNodeEnveloper::LoopStart' has a wrong offset!");
static_assert(offsetof(USoundNodeEnveloper, LoopEnd) == 0x00004C, "Member 'USoundNodeEnveloper::LoopEnd' has a wrong offset!");
static_assert(offsetof(USoundNodeEnveloper, DurationAfterLoop) == 0x000050, "Member 'USoundNodeEnveloper::DurationAfterLoop' has a wrong offset!");
static_assert(offsetof(USoundNodeEnveloper, LoopCount) == 0x000054, "Member 'USoundNodeEnveloper::LoopCount' has a wrong offset!");
static_assert(offsetof(USoundNodeEnveloper, VolumeInterpCurve) == 0x000060, "Member 'USoundNodeEnveloper::VolumeInterpCurve' has a wrong offset!");
static_assert(offsetof(USoundNodeEnveloper, PitchInterpCurve) == 0x000068, "Member 'USoundNodeEnveloper::PitchInterpCurve' has a wrong offset!");
static_assert(offsetof(USoundNodeEnveloper, VolumeCurve) == 0x000070, "Member 'USoundNodeEnveloper::VolumeCurve' has a wrong offset!");
static_assert(offsetof(USoundNodeEnveloper, PitchCurve) == 0x0000F8, "Member 'USoundNodeEnveloper::PitchCurve' has a wrong offset!");
static_assert(offsetof(USoundNodeEnveloper, PitchMin) == 0x000180, "Member 'USoundNodeEnveloper::PitchMin' has a wrong offset!");
static_assert(offsetof(USoundNodeEnveloper, PitchMax) == 0x000184, "Member 'USoundNodeEnveloper::PitchMax' has a wrong offset!");
static_assert(offsetof(USoundNodeEnveloper, VolumeMin) == 0x000188, "Member 'USoundNodeEnveloper::VolumeMin' has a wrong offset!");
static_assert(offsetof(USoundNodeEnveloper, VolumeMax) == 0x00018C, "Member 'USoundNodeEnveloper::VolumeMax' has a wrong offset!");

// Class Engine.MaterialExpressionStrataConvertToDecal
// 0x0050 (0x0100 - 0x00B0)
class UMaterialExpressionStrataConvertToDecal final : public UMaterialExpressionStrataBSDF
{
public:
	struct FExpressionInput                       DecalMaterial;                                     // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       Coverage;                                          // 0x00D8(0x0028)(NoDestructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionStrataConvertToDecal">();
	}
	static class UMaterialExpressionStrataConvertToDecal* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionStrataConvertToDecal>();
	}
};
static_assert(alignof(UMaterialExpressionStrataConvertToDecal) == 0x000008, "Wrong alignment on UMaterialExpressionStrataConvertToDecal");
static_assert(sizeof(UMaterialExpressionStrataConvertToDecal) == 0x000100, "Wrong size on UMaterialExpressionStrataConvertToDecal");
static_assert(offsetof(UMaterialExpressionStrataConvertToDecal, DecalMaterial) == 0x0000B0, "Member 'UMaterialExpressionStrataConvertToDecal::DecalMaterial' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionStrataConvertToDecal, Coverage) == 0x0000D8, "Member 'UMaterialExpressionStrataConvertToDecal::Coverage' has a wrong offset!");

// Class Engine.ExponentialHeightFogComponent
// 0x00E0 (0x0380 - 0x02A0)
class UExponentialHeightFogComponent final : public USceneComponent
{
public:
	float                                         FogDensity;                                        // 0x02A0(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         FogHeightFalloff;                                  // 0x02A4(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FExponentialHeightFogData              SecondFogData;                                     // 0x02A8(0x000C)(Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, NativeAccessSpecifierPublic)
	struct FLinearColor                           FogInscatteringColor;                              // 0x02B4(0x0010)(ZeroConstructor, Deprecated, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FLinearColor                           FogInscatteringLuminance;                          // 0x02C4(0x0010)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FLinearColor                           SkyAtmosphereAmbientContributionColorScale;        // 0x02D4(0x0010)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_2E4[0x4];                                      // 0x02E4(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	class UTextureCube*                           InscatteringColorCubemap;                          // 0x02E8(0x0008)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         InscatteringColorCubemapAngle;                     // 0x02F0(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FLinearColor                           InscatteringTextureTint;                           // 0x02F4(0x0010)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         FullyDirectionalInscatteringColorDistance;         // 0x0304(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         NonDirectionalInscatteringColorDistance;           // 0x0308(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         DirectionalInscatteringExponent;                   // 0x030C(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         DirectionalInscatteringStartDistance;              // 0x0310(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FLinearColor                           DirectionalInscatteringColor;                      // 0x0314(0x0010)(ZeroConstructor, Deprecated, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FLinearColor                           DirectionalInscatteringLuminance;                  // 0x0324(0x0010)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         FogMaxOpacity;                                     // 0x0334(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         StartDistance;                                     // 0x0338(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         FogCutoffDistance;                                 // 0x033C(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bEnableVolumetricFog;                              // 0x0340(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_341[0x3];                                      // 0x0341(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         VolumetricFogScatteringDistribution;               // 0x0344(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FColor                                 VolumetricFogAlbedo;                               // 0x0348(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FLinearColor                           VolumetricFogEmissive;                             // 0x034C(0x0010)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         VolumetricFogExtinctionScale;                      // 0x035C(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         VolumetricFogDistance;                             // 0x0360(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         VolumetricFogStartDistance;                        // 0x0364(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         VolumetricFogNearFadeInDistance;                   // 0x0368(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         VolumetricFogStaticLightingScatteringIntensity;    // 0x036C(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bOverrideLightColorsWithFogInscatteringColors;     // 0x0370(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_371[0xF];                                      // 0x0371(0x000F)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void SetDirectionalInscatteringColor(const struct FLinearColor& Value);
	void SetDirectionalInscatteringExponent(float Value);
	void SetDirectionalInscatteringStartDistance(float Value);
	void SetFogCutoffDistance(float Value);
	void SetFogDensity(float Value);
	void SetFogHeightFalloff(float Value);
	void SetFogInscatteringColor(const struct FLinearColor& Value);
	void SetFogMaxOpacity(float Value);
	void SetFullyDirectionalInscatteringColorDistance(float Value);
	void SetInscatteringColorCubemap(class UTextureCube* Value);
	void SetInscatteringColorCubemapAngle(float Value);
	void SetInscatteringTextureTint(const struct FLinearColor& Value);
	void SetNonDirectionalInscatteringColorDistance(float Value);
	void SetSecondFogData(const struct FExponentialHeightFogData& NewValue);
	void SetSecondFogDensity(float Value);
	void SetSecondFogHeightFalloff(float Value);
	void SetSecondFogHeightOffset(float Value);
	void SetStartDistance(float Value);
	void SetVolumetricFog(bool bNewValue);
	void SetVolumetricFogAlbedo(const struct FColor& NewValue);
	void SetVolumetricFogDistance(float NewValue);
	void SetVolumetricFogEmissive(const struct FLinearColor& NewValue);
	void SetVolumetricFogExtinctionScale(float NewValue);
	void SetVolumetricFogScatteringDistribution(float NewValue);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ExponentialHeightFogComponent">();
	}
	static class UExponentialHeightFogComponent* GetDefaultObj()
	{
		return GetDefaultObjImpl<UExponentialHeightFogComponent>();
	}
};
static_assert(alignof(UExponentialHeightFogComponent) == 0x000010, "Wrong alignment on UExponentialHeightFogComponent");
static_assert(sizeof(UExponentialHeightFogComponent) == 0x000380, "Wrong size on UExponentialHeightFogComponent");
static_assert(offsetof(UExponentialHeightFogComponent, FogDensity) == 0x0002A0, "Member 'UExponentialHeightFogComponent::FogDensity' has a wrong offset!");
static_assert(offsetof(UExponentialHeightFogComponent, FogHeightFalloff) == 0x0002A4, "Member 'UExponentialHeightFogComponent::FogHeightFalloff' has a wrong offset!");
static_assert(offsetof(UExponentialHeightFogComponent, SecondFogData) == 0x0002A8, "Member 'UExponentialHeightFogComponent::SecondFogData' has a wrong offset!");
static_assert(offsetof(UExponentialHeightFogComponent, FogInscatteringColor) == 0x0002B4, "Member 'UExponentialHeightFogComponent::FogInscatteringColor' has a wrong offset!");
static_assert(offsetof(UExponentialHeightFogComponent, FogInscatteringLuminance) == 0x0002C4, "Member 'UExponentialHeightFogComponent::FogInscatteringLuminance' has a wrong offset!");
static_assert(offsetof(UExponentialHeightFogComponent, SkyAtmosphereAmbientContributionColorScale) == 0x0002D4, "Member 'UExponentialHeightFogComponent::SkyAtmosphereAmbientContributionColorScale' has a wrong offset!");
static_assert(offsetof(UExponentialHeightFogComponent, InscatteringColorCubemap) == 0x0002E8, "Member 'UExponentialHeightFogComponent::InscatteringColorCubemap' has a wrong offset!");
static_assert(offsetof(UExponentialHeightFogComponent, InscatteringColorCubemapAngle) == 0x0002F0, "Member 'UExponentialHeightFogComponent::InscatteringColorCubemapAngle' has a wrong offset!");
static_assert(offsetof(UExponentialHeightFogComponent, InscatteringTextureTint) == 0x0002F4, "Member 'UExponentialHeightFogComponent::InscatteringTextureTint' has a wrong offset!");
static_assert(offsetof(UExponentialHeightFogComponent, FullyDirectionalInscatteringColorDistance) == 0x000304, "Member 'UExponentialHeightFogComponent::FullyDirectionalInscatteringColorDistance' has a wrong offset!");
static_assert(offsetof(UExponentialHeightFogComponent, NonDirectionalInscatteringColorDistance) == 0x000308, "Member 'UExponentialHeightFogComponent::NonDirectionalInscatteringColorDistance' has a wrong offset!");
static_assert(offsetof(UExponentialHeightFogComponent, DirectionalInscatteringExponent) == 0x00030C, "Member 'UExponentialHeightFogComponent::DirectionalInscatteringExponent' has a wrong offset!");
static_assert(offsetof(UExponentialHeightFogComponent, DirectionalInscatteringStartDistance) == 0x000310, "Member 'UExponentialHeightFogComponent::DirectionalInscatteringStartDistance' has a wrong offset!");
static_assert(offsetof(UExponentialHeightFogComponent, DirectionalInscatteringColor) == 0x000314, "Member 'UExponentialHeightFogComponent::DirectionalInscatteringColor' has a wrong offset!");
static_assert(offsetof(UExponentialHeightFogComponent, DirectionalInscatteringLuminance) == 0x000324, "Member 'UExponentialHeightFogComponent::DirectionalInscatteringLuminance' has a wrong offset!");
static_assert(offsetof(UExponentialHeightFogComponent, FogMaxOpacity) == 0x000334, "Member 'UExponentialHeightFogComponent::FogMaxOpacity' has a wrong offset!");
static_assert(offsetof(UExponentialHeightFogComponent, StartDistance) == 0x000338, "Member 'UExponentialHeightFogComponent::StartDistance' has a wrong offset!");
static_assert(offsetof(UExponentialHeightFogComponent, FogCutoffDistance) == 0x00033C, "Member 'UExponentialHeightFogComponent::FogCutoffDistance' has a wrong offset!");
static_assert(offsetof(UExponentialHeightFogComponent, bEnableVolumetricFog) == 0x000340, "Member 'UExponentialHeightFogComponent::bEnableVolumetricFog' has a wrong offset!");
static_assert(offsetof(UExponentialHeightFogComponent, VolumetricFogScatteringDistribution) == 0x000344, "Member 'UExponentialHeightFogComponent::VolumetricFogScatteringDistribution' has a wrong offset!");
static_assert(offsetof(UExponentialHeightFogComponent, VolumetricFogAlbedo) == 0x000348, "Member 'UExponentialHeightFogComponent::VolumetricFogAlbedo' has a wrong offset!");
static_assert(offsetof(UExponentialHeightFogComponent, VolumetricFogEmissive) == 0x00034C, "Member 'UExponentialHeightFogComponent::VolumetricFogEmissive' has a wrong offset!");
static_assert(offsetof(UExponentialHeightFogComponent, VolumetricFogExtinctionScale) == 0x00035C, "Member 'UExponentialHeightFogComponent::VolumetricFogExtinctionScale' has a wrong offset!");
static_assert(offsetof(UExponentialHeightFogComponent, VolumetricFogDistance) == 0x000360, "Member 'UExponentialHeightFogComponent::VolumetricFogDistance' has a wrong offset!");
static_assert(offsetof(UExponentialHeightFogComponent, VolumetricFogStartDistance) == 0x000364, "Member 'UExponentialHeightFogComponent::VolumetricFogStartDistance' has a wrong offset!");
static_assert(offsetof(UExponentialHeightFogComponent, VolumetricFogNearFadeInDistance) == 0x000368, "Member 'UExponentialHeightFogComponent::VolumetricFogNearFadeInDistance' has a wrong offset!");
static_assert(offsetof(UExponentialHeightFogComponent, VolumetricFogStaticLightingScatteringIntensity) == 0x00036C, "Member 'UExponentialHeightFogComponent::VolumetricFogStaticLightingScatteringIntensity' has a wrong offset!");
static_assert(offsetof(UExponentialHeightFogComponent, bOverrideLightColorsWithFogInscatteringColors) == 0x000370, "Member 'UExponentialHeightFogComponent::bOverrideLightColorsWithFogInscatteringColors' has a wrong offset!");

// Class Engine.Exporter
// 0x0050 (0x0078 - 0x0028)
class UExporter final : public UObject
{
public:
	TSubclassOf<class UObject>                    SupportedClass;                                    // 0x0028(0x0008)(BlueprintVisible, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UObject*                                ExportRootScope;                                   // 0x0030(0x0008)(ZeroConstructor, Transient, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TArray<class FString>                         FormatExtension;                                   // 0x0038(0x0010)(BlueprintVisible, ZeroConstructor, NativeAccessSpecifierPublic)
	TArray<class FString>                         FormatDescription;                                 // 0x0048(0x0010)(BlueprintVisible, ZeroConstructor, NativeAccessSpecifierPublic)
	int32                                         PreferredFormatIndex;                              // 0x0058(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         TextIndent;                                        // 0x005C(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bText : 1;                                         // 0x0060(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bSelectedOnly : 1;                                 // 0x0060(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bForceFileOperations : 1;                          // 0x0060(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_61[0x7];                                       // 0x0061(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	class UAssetExportTask*                       ExportTask;                                        // 0x0068(0x0008)(BlueprintVisible, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_70[0x8];                                       // 0x0070(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static bool RunAssetExportTask(class UAssetExportTask* Task);
	static bool RunAssetExportTasks(const TArray<class UAssetExportTask*>& ExportTasks);

	bool ScriptRunAssetExportTask(class UAssetExportTask* Task);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"Exporter">();
	}
	static class UExporter* GetDefaultObj()
	{
		return GetDefaultObjImpl<UExporter>();
	}
};
static_assert(alignof(UExporter) == 0x000008, "Wrong alignment on UExporter");
static_assert(sizeof(UExporter) == 0x000078, "Wrong size on UExporter");
static_assert(offsetof(UExporter, SupportedClass) == 0x000028, "Member 'UExporter::SupportedClass' has a wrong offset!");
static_assert(offsetof(UExporter, ExportRootScope) == 0x000030, "Member 'UExporter::ExportRootScope' has a wrong offset!");
static_assert(offsetof(UExporter, FormatExtension) == 0x000038, "Member 'UExporter::FormatExtension' has a wrong offset!");
static_assert(offsetof(UExporter, FormatDescription) == 0x000048, "Member 'UExporter::FormatDescription' has a wrong offset!");
static_assert(offsetof(UExporter, PreferredFormatIndex) == 0x000058, "Member 'UExporter::PreferredFormatIndex' has a wrong offset!");
static_assert(offsetof(UExporter, TextIndent) == 0x00005C, "Member 'UExporter::TextIndent' has a wrong offset!");
static_assert(offsetof(UExporter, ExportTask) == 0x000068, "Member 'UExporter::ExportTask' has a wrong offset!");

// Class Engine.MaterialExpressionDepthOfFieldFunction
// 0x0030 (0x00E0 - 0x00B0)
class UMaterialExpressionDepthOfFieldFunction final : public UMaterialExpression
{
public:
	EDepthOfFieldFunctionValue                    FunctionValue;                                     // 0x00B0(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_B1[0x7];                                       // 0x00B1(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	struct FExpressionInput                       Depth;                                             // 0x00B8(0x0028)(NoDestructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionDepthOfFieldFunction">();
	}
	static class UMaterialExpressionDepthOfFieldFunction* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionDepthOfFieldFunction>();
	}
};
static_assert(alignof(UMaterialExpressionDepthOfFieldFunction) == 0x000008, "Wrong alignment on UMaterialExpressionDepthOfFieldFunction");
static_assert(sizeof(UMaterialExpressionDepthOfFieldFunction) == 0x0000E0, "Wrong size on UMaterialExpressionDepthOfFieldFunction");
static_assert(offsetof(UMaterialExpressionDepthOfFieldFunction, FunctionValue) == 0x0000B0, "Member 'UMaterialExpressionDepthOfFieldFunction::FunctionValue' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionDepthOfFieldFunction, Depth) == 0x0000B8, "Member 'UMaterialExpressionDepthOfFieldFunction::Depth' has a wrong offset!");

// Class Engine.FieldNotificationLibrary
// 0x0000 (0x0028 - 0x0028)
class UFieldNotificationLibrary final : public UBlueprintFunctionLibrary
{
public:
	static void BroadcastFieldsValueChanged(class UObject* Object, const TArray<struct FFieldNotificationId>& FieldIds);
	static void BroadcastFieldValueChanged(class UObject* Object, const struct FFieldNotificationId& FieldId);
	static bool SetPropertyValueAndBroadcast(bool NewValueByRef, const int32& OldValue, const int32& NewValue, class UObject* Object, class UObject* NetOwner, bool bHasLocalRepNotify, bool bShouldFlushDormancyOnSet, bool bIsNetProperty);
	static bool SetPropertyValueAndBroadcastFields(bool NewValueByRef, const int32& OldValue, const int32& NewValue, class UObject* Object, class UObject* NetOwner, bool bHasLocalRepNotify, bool bShouldFlushDormancyOnSet, bool bIsNetProperty, const TArray<struct FFieldNotificationId>& ExtraFieldIds);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"FieldNotificationLibrary">();
	}
	static class UFieldNotificationLibrary* GetDefaultObj()
	{
		return GetDefaultObjImpl<UFieldNotificationLibrary>();
	}
};
static_assert(alignof(UFieldNotificationLibrary) == 0x000008, "Wrong alignment on UFieldNotificationLibrary");
static_assert(sizeof(UFieldNotificationLibrary) == 0x000028, "Wrong size on UFieldNotificationLibrary");

// Class Engine.AnimCurveCompressionCodec_CompressedRichCurve
// 0x0000 (0x0038 - 0x0038)
class UAnimCurveCompressionCodec_CompressedRichCurve final : public UAnimCurveCompressionCodec
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AnimCurveCompressionCodec_CompressedRichCurve">();
	}
	static class UAnimCurveCompressionCodec_CompressedRichCurve* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAnimCurveCompressionCodec_CompressedRichCurve>();
	}
};
static_assert(alignof(UAnimCurveCompressionCodec_CompressedRichCurve) == 0x000008, "Wrong alignment on UAnimCurveCompressionCodec_CompressedRichCurve");
static_assert(sizeof(UAnimCurveCompressionCodec_CompressedRichCurve) == 0x000038, "Wrong size on UAnimCurveCompressionCodec_CompressedRichCurve");

// Class Engine.ParticleModuleAttractorPointGravity
// 0x0058 (0x0088 - 0x0030)
class UParticleModuleAttractorPointGravity final : public UParticleModuleAttractorBase
{
public:
	struct FVector                                position;                                          // 0x0030(0x0018)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         Radius;                                            // 0x0048(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_4C[0x4];                                       // 0x004C(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	class UDistributionFloat*                     Strength;                                          // 0x0050(0x0008)(ExportObject, ZeroConstructor, InstancedReference, Deprecated, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FRawDistributionFloat                  StrengthRaw;                                       // 0x0058(0x0030)(Edit, NoClear, ContainsInstancedReference, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ParticleModuleAttractorPointGravity">();
	}
	static class UParticleModuleAttractorPointGravity* GetDefaultObj()
	{
		return GetDefaultObjImpl<UParticleModuleAttractorPointGravity>();
	}
};
static_assert(alignof(UParticleModuleAttractorPointGravity) == 0x000008, "Wrong alignment on UParticleModuleAttractorPointGravity");
static_assert(sizeof(UParticleModuleAttractorPointGravity) == 0x000088, "Wrong size on UParticleModuleAttractorPointGravity");
static_assert(offsetof(UParticleModuleAttractorPointGravity, position) == 0x000030, "Member 'UParticleModuleAttractorPointGravity::position' has a wrong offset!");
static_assert(offsetof(UParticleModuleAttractorPointGravity, Radius) == 0x000048, "Member 'UParticleModuleAttractorPointGravity::Radius' has a wrong offset!");
static_assert(offsetof(UParticleModuleAttractorPointGravity, Strength) == 0x000050, "Member 'UParticleModuleAttractorPointGravity::Strength' has a wrong offset!");
static_assert(offsetof(UParticleModuleAttractorPointGravity, StrengthRaw) == 0x000058, "Member 'UParticleModuleAttractorPointGravity::StrengthRaw' has a wrong offset!");

// Class Engine.FontImportOptions
// 0x00B0 (0x00D8 - 0x0028)
class UFontImportOptions final : public UObject
{
public:
	struct FFontImportOptionsData                 Data;                                              // 0x0028(0x00B0)(Edit, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"FontImportOptions">();
	}
	static class UFontImportOptions* GetDefaultObj()
	{
		return GetDefaultObjImpl<UFontImportOptions>();
	}
};
static_assert(alignof(UFontImportOptions) == 0x000008, "Wrong alignment on UFontImportOptions");
static_assert(sizeof(UFontImportOptions) == 0x0000D8, "Wrong size on UFontImportOptions");
static_assert(offsetof(UFontImportOptions, Data) == 0x000028, "Member 'UFontImportOptions::Data' has a wrong offset!");

// Class Engine.VolumeTexture
// 0x00A0 (0x0270 - 0x01D0)
class UVolumeTexture final : public UTexture
{
public:
	uint8                                         Pad_1C8[0x98];                                     // 0x01C8(0x0098)(Fixing Size After Last Property [ Dumper-7 ])
	ETextureAddress                               AddressMode;                                       // 0x0260(0x0001)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, AssetRegistrySearchable, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_261[0xF];                                      // 0x0261(0x000F)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"VolumeTexture">();
	}
	static class UVolumeTexture* GetDefaultObj()
	{
		return GetDefaultObjImpl<UVolumeTexture>();
	}
};
static_assert(alignof(UVolumeTexture) == 0x000010, "Wrong alignment on UVolumeTexture");
static_assert(sizeof(UVolumeTexture) == 0x000270, "Wrong size on UVolumeTexture");
static_assert(offsetof(UVolumeTexture, AddressMode) == 0x000260, "Member 'UVolumeTexture::AddressMode' has a wrong offset!");

// Class Engine.MaterialExpressionSkyAtmosphereLightIlluminance
// 0x0030 (0x00E0 - 0x00B0)
class UMaterialExpressionSkyAtmosphereLightIlluminance final : public UMaterialExpression
{
public:
	int32                                         LightIndex;                                        // 0x00B0(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_B4[0x4];                                       // 0x00B4(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	struct FExpressionInput                       WorldPosition;                                     // 0x00B8(0x0028)(NoDestructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionSkyAtmosphereLightIlluminance">();
	}
	static class UMaterialExpressionSkyAtmosphereLightIlluminance* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionSkyAtmosphereLightIlluminance>();
	}
};
static_assert(alignof(UMaterialExpressionSkyAtmosphereLightIlluminance) == 0x000008, "Wrong alignment on UMaterialExpressionSkyAtmosphereLightIlluminance");
static_assert(sizeof(UMaterialExpressionSkyAtmosphereLightIlluminance) == 0x0000E0, "Wrong size on UMaterialExpressionSkyAtmosphereLightIlluminance");
static_assert(offsetof(UMaterialExpressionSkyAtmosphereLightIlluminance, LightIndex) == 0x0000B0, "Member 'UMaterialExpressionSkyAtmosphereLightIlluminance::LightIndex' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionSkyAtmosphereLightIlluminance, WorldPosition) == 0x0000B8, "Member 'UMaterialExpressionSkyAtmosphereLightIlluminance::WorldPosition' has a wrong offset!");

// Class Engine.ForceFeedbackAttenuation
// 0x00C0 (0x00E8 - 0x0028)
class UForceFeedbackAttenuation final : public UObject
{
public:
	struct FForceFeedbackAttenuationSettings      Attenuation;                                       // 0x0028(0x00C0)(Edit, BlueprintVisible, BlueprintReadOnly, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ForceFeedbackAttenuation">();
	}
	static class UForceFeedbackAttenuation* GetDefaultObj()
	{
		return GetDefaultObjImpl<UForceFeedbackAttenuation>();
	}
};
static_assert(alignof(UForceFeedbackAttenuation) == 0x000008, "Wrong alignment on UForceFeedbackAttenuation");
static_assert(sizeof(UForceFeedbackAttenuation) == 0x0000E8, "Wrong size on UForceFeedbackAttenuation");
static_assert(offsetof(UForceFeedbackAttenuation, Attenuation) == 0x000028, "Member 'UForceFeedbackAttenuation::Attenuation' has a wrong offset!");

// Class Engine.CameraShakeSourceComponent
// 0x0020 (0x02C0 - 0x02A0)
class UCameraShakeSourceComponent final : public USceneComponent
{
public:
	ECameraShakeAttenuation                       Attenuation;                                       // 0x02A0(0x0001)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_2A1[0x3];                                      // 0x02A1(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         InnerAttenuationRadius;                            // 0x02A4(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         OuterAttenuationRadius;                            // 0x02A8(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_2AC[0x4];                                      // 0x02AC(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	TSubclassOf<class UCameraShakeBase>           CameraShake;                                       // 0x02B0(0x0008)(Edit, BlueprintVisible, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bAutoStart;                                        // 0x02B8(0x0001)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_2B9[0x7];                                      // 0x02B9(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void START();
	void StartCameraShake(TSubclassOf<class UCameraShakeBase> InCameraShake, float Scale, ECameraShakePlaySpace PlaySpace, const struct FRotator& UserPlaySpaceRot);
	void StopAllCameraShakes(bool bImmediately);
	void StopAllCameraShakesOfType(TSubclassOf<class UCameraShakeBase> InCameraShake, bool bImmediately);

	float GetAttenuationFactor(const struct FVector& Location) const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"CameraShakeSourceComponent">();
	}
	static class UCameraShakeSourceComponent* GetDefaultObj()
	{
		return GetDefaultObjImpl<UCameraShakeSourceComponent>();
	}
};
static_assert(alignof(UCameraShakeSourceComponent) == 0x000010, "Wrong alignment on UCameraShakeSourceComponent");
static_assert(sizeof(UCameraShakeSourceComponent) == 0x0002C0, "Wrong size on UCameraShakeSourceComponent");
static_assert(offsetof(UCameraShakeSourceComponent, Attenuation) == 0x0002A0, "Member 'UCameraShakeSourceComponent::Attenuation' has a wrong offset!");
static_assert(offsetof(UCameraShakeSourceComponent, InnerAttenuationRadius) == 0x0002A4, "Member 'UCameraShakeSourceComponent::InnerAttenuationRadius' has a wrong offset!");
static_assert(offsetof(UCameraShakeSourceComponent, OuterAttenuationRadius) == 0x0002A8, "Member 'UCameraShakeSourceComponent::OuterAttenuationRadius' has a wrong offset!");
static_assert(offsetof(UCameraShakeSourceComponent, CameraShake) == 0x0002B0, "Member 'UCameraShakeSourceComponent::CameraShake' has a wrong offset!");
static_assert(offsetof(UCameraShakeSourceComponent, bAutoStart) == 0x0002B8, "Member 'UCameraShakeSourceComponent::bAutoStart' has a wrong offset!");

// Class Engine.MaterialExpressionLightVector
// 0x0000 (0x00B0 - 0x00B0)
class UMaterialExpressionLightVector final : public UMaterialExpression
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionLightVector">();
	}
	static class UMaterialExpressionLightVector* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionLightVector>();
	}
};
static_assert(alignof(UMaterialExpressionLightVector) == 0x000008, "Wrong alignment on UMaterialExpressionLightVector");
static_assert(sizeof(UMaterialExpressionLightVector) == 0x0000B0, "Wrong size on UMaterialExpressionLightVector");

// Class Engine.GameNetworkManager
// 0x00A8 (0x0348 - 0x02A0)
class AGameNetworkManager final : public AInfo
{
public:
	float                                         BadPacketLossThreshold;                            // 0x02A0(0x0004)(ZeroConstructor, Config, GlobalConfig, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         SeverePacketLossThreshold;                         // 0x02A4(0x0004)(ZeroConstructor, Config, GlobalConfig, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         BadPingThreshold;                                  // 0x02A8(0x0004)(ZeroConstructor, Config, GlobalConfig, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         SeverePingThreshold;                               // 0x02AC(0x0004)(ZeroConstructor, Config, GlobalConfig, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         AdjustedNetSpeed;                                  // 0x02B0(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         LastNetSpeedUpdateTime;                            // 0x02B4(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         TotalNetBandwidth;                                 // 0x02B8(0x0004)(ZeroConstructor, Config, GlobalConfig, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         MinDynamicBandwidth;                               // 0x02BC(0x0004)(ZeroConstructor, Config, GlobalConfig, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         MaxDynamicBandwidth;                               // 0x02C0(0x0004)(ZeroConstructor, Config, GlobalConfig, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bIsStandbyCheckingEnabled : 1;                     // 0x02C4(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bHasStandbyCheatTriggered : 1;                     // 0x02C4(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_2C5[0x3];                                      // 0x02C5(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         StandbyRxCheatTime;                                // 0x02C8(0x0004)(ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         StandbyTxCheatTime;                                // 0x02CC(0x0004)(ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         PercentMissingForRxStandby;                        // 0x02D0(0x0004)(ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         PercentMissingForTxStandby;                        // 0x02D4(0x0004)(ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         PercentForBadPing;                                 // 0x02D8(0x0004)(ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         JoinInProgressStandbyWaitTime;                     // 0x02DC(0x0004)(ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         MoveRepSize;                                       // 0x02E0(0x0004)(ZeroConstructor, Config, GlobalConfig, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         MAXPOSITIONERRORSQUARED;                           // 0x02E4(0x0004)(ZeroConstructor, Config, GlobalConfig, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         MAXNEARZEROVELOCITYSQUARED;                        // 0x02E8(0x0004)(ZeroConstructor, Config, GlobalConfig, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         CLIENTADJUSTUPDATECOST;                            // 0x02EC(0x0004)(ZeroConstructor, Config, GlobalConfig, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         MAXCLIENTUPDATEINTERVAL;                           // 0x02F0(0x0004)(ZeroConstructor, Config, GlobalConfig, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         MaxClientForcedUpdateDuration;                     // 0x02F4(0x0004)(ZeroConstructor, Config, GlobalConfig, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         ServerForcedUpdateHitchThreshold;                  // 0x02F8(0x0004)(ZeroConstructor, Config, GlobalConfig, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         ServerForcedUpdateHitchCooldown;                   // 0x02FC(0x0004)(ZeroConstructor, Config, GlobalConfig, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         MaxMoveDeltaTime;                                  // 0x0300(0x0004)(ZeroConstructor, Config, GlobalConfig, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         MaxClientSmoothingDeltaTime;                       // 0x0304(0x0004)(ZeroConstructor, Config, GlobalConfig, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         ClientNetSendMoveDeltaTime;                        // 0x0308(0x0004)(ZeroConstructor, Config, GlobalConfig, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         ClientNetSendMoveDeltaTimeThrottled;               // 0x030C(0x0004)(ZeroConstructor, Config, GlobalConfig, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         ClientNetSendMoveDeltaTimeStationary;              // 0x0310(0x0004)(ZeroConstructor, Config, GlobalConfig, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         ClientNetSendMoveThrottleAtNetSpeed;               // 0x0314(0x0004)(ZeroConstructor, Config, GlobalConfig, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         ClientNetSendMoveThrottleOverPlayerCount;          // 0x0318(0x0004)(ZeroConstructor, Config, GlobalConfig, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         ClientErrorUpdateRateLimit;                        // 0x031C(0x0004)(ZeroConstructor, Config, GlobalConfig, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         ClientNetCamUpdateDeltaTime;                       // 0x0320(0x0004)(ZeroConstructor, Config, GlobalConfig, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         ClientNetCamUpdatePositionLimit;                   // 0x0324(0x0004)(ZeroConstructor, Config, GlobalConfig, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ClientAuthorativePosition;                         // 0x0328(0x0001)(ZeroConstructor, Config, GlobalConfig, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bMovementTimeDiscrepancyDetection;                 // 0x0329(0x0001)(ZeroConstructor, Config, GlobalConfig, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bMovementTimeDiscrepancyResolution;                // 0x032A(0x0001)(ZeroConstructor, Config, GlobalConfig, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_32B[0x1];                                      // 0x032B(0x0001)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         MovementTimeDiscrepancyMaxTimeMargin;              // 0x032C(0x0004)(ZeroConstructor, Config, GlobalConfig, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         MovementTimeDiscrepancyMinTimeMargin;              // 0x0330(0x0004)(ZeroConstructor, Config, GlobalConfig, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         MovementTimeDiscrepancyResolutionRate;             // 0x0334(0x0004)(ZeroConstructor, Config, GlobalConfig, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         MovementTimeDiscrepancyDriftAllowance;             // 0x0338(0x0004)(ZeroConstructor, Config, GlobalConfig, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bMovementTimeDiscrepancyForceCorrectionsDuringResolution; // 0x033C(0x0001)(ZeroConstructor, Config, GlobalConfig, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bUseDistanceBasedRelevancy;                        // 0x033D(0x0001)(ZeroConstructor, Config, GlobalConfig, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_33E[0xA];                                      // 0x033E(0x000A)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"GameNetworkManager">();
	}
	static class AGameNetworkManager* GetDefaultObj()
	{
		return GetDefaultObjImpl<AGameNetworkManager>();
	}
};
static_assert(alignof(AGameNetworkManager) == 0x000008, "Wrong alignment on AGameNetworkManager");
static_assert(sizeof(AGameNetworkManager) == 0x000348, "Wrong size on AGameNetworkManager");
static_assert(offsetof(AGameNetworkManager, BadPacketLossThreshold) == 0x0002A0, "Member 'AGameNetworkManager::BadPacketLossThreshold' has a wrong offset!");
static_assert(offsetof(AGameNetworkManager, SeverePacketLossThreshold) == 0x0002A4, "Member 'AGameNetworkManager::SeverePacketLossThreshold' has a wrong offset!");
static_assert(offsetof(AGameNetworkManager, BadPingThreshold) == 0x0002A8, "Member 'AGameNetworkManager::BadPingThreshold' has a wrong offset!");
static_assert(offsetof(AGameNetworkManager, SeverePingThreshold) == 0x0002AC, "Member 'AGameNetworkManager::SeverePingThreshold' has a wrong offset!");
static_assert(offsetof(AGameNetworkManager, AdjustedNetSpeed) == 0x0002B0, "Member 'AGameNetworkManager::AdjustedNetSpeed' has a wrong offset!");
static_assert(offsetof(AGameNetworkManager, LastNetSpeedUpdateTime) == 0x0002B4, "Member 'AGameNetworkManager::LastNetSpeedUpdateTime' has a wrong offset!");
static_assert(offsetof(AGameNetworkManager, TotalNetBandwidth) == 0x0002B8, "Member 'AGameNetworkManager::TotalNetBandwidth' has a wrong offset!");
static_assert(offsetof(AGameNetworkManager, MinDynamicBandwidth) == 0x0002BC, "Member 'AGameNetworkManager::MinDynamicBandwidth' has a wrong offset!");
static_assert(offsetof(AGameNetworkManager, MaxDynamicBandwidth) == 0x0002C0, "Member 'AGameNetworkManager::MaxDynamicBandwidth' has a wrong offset!");
static_assert(offsetof(AGameNetworkManager, StandbyRxCheatTime) == 0x0002C8, "Member 'AGameNetworkManager::StandbyRxCheatTime' has a wrong offset!");
static_assert(offsetof(AGameNetworkManager, StandbyTxCheatTime) == 0x0002CC, "Member 'AGameNetworkManager::StandbyTxCheatTime' has a wrong offset!");
static_assert(offsetof(AGameNetworkManager, PercentMissingForRxStandby) == 0x0002D0, "Member 'AGameNetworkManager::PercentMissingForRxStandby' has a wrong offset!");
static_assert(offsetof(AGameNetworkManager, PercentMissingForTxStandby) == 0x0002D4, "Member 'AGameNetworkManager::PercentMissingForTxStandby' has a wrong offset!");
static_assert(offsetof(AGameNetworkManager, PercentForBadPing) == 0x0002D8, "Member 'AGameNetworkManager::PercentForBadPing' has a wrong offset!");
static_assert(offsetof(AGameNetworkManager, JoinInProgressStandbyWaitTime) == 0x0002DC, "Member 'AGameNetworkManager::JoinInProgressStandbyWaitTime' has a wrong offset!");
static_assert(offsetof(AGameNetworkManager, MoveRepSize) == 0x0002E0, "Member 'AGameNetworkManager::MoveRepSize' has a wrong offset!");
static_assert(offsetof(AGameNetworkManager, MAXPOSITIONERRORSQUARED) == 0x0002E4, "Member 'AGameNetworkManager::MAXPOSITIONERRORSQUARED' has a wrong offset!");
static_assert(offsetof(AGameNetworkManager, MAXNEARZEROVELOCITYSQUARED) == 0x0002E8, "Member 'AGameNetworkManager::MAXNEARZEROVELOCITYSQUARED' has a wrong offset!");
static_assert(offsetof(AGameNetworkManager, CLIENTADJUSTUPDATECOST) == 0x0002EC, "Member 'AGameNetworkManager::CLIENTADJUSTUPDATECOST' has a wrong offset!");
static_assert(offsetof(AGameNetworkManager, MAXCLIENTUPDATEINTERVAL) == 0x0002F0, "Member 'AGameNetworkManager::MAXCLIENTUPDATEINTERVAL' has a wrong offset!");
static_assert(offsetof(AGameNetworkManager, MaxClientForcedUpdateDuration) == 0x0002F4, "Member 'AGameNetworkManager::MaxClientForcedUpdateDuration' has a wrong offset!");
static_assert(offsetof(AGameNetworkManager, ServerForcedUpdateHitchThreshold) == 0x0002F8, "Member 'AGameNetworkManager::ServerForcedUpdateHitchThreshold' has a wrong offset!");
static_assert(offsetof(AGameNetworkManager, ServerForcedUpdateHitchCooldown) == 0x0002FC, "Member 'AGameNetworkManager::ServerForcedUpdateHitchCooldown' has a wrong offset!");
static_assert(offsetof(AGameNetworkManager, MaxMoveDeltaTime) == 0x000300, "Member 'AGameNetworkManager::MaxMoveDeltaTime' has a wrong offset!");
static_assert(offsetof(AGameNetworkManager, MaxClientSmoothingDeltaTime) == 0x000304, "Member 'AGameNetworkManager::MaxClientSmoothingDeltaTime' has a wrong offset!");
static_assert(offsetof(AGameNetworkManager, ClientNetSendMoveDeltaTime) == 0x000308, "Member 'AGameNetworkManager::ClientNetSendMoveDeltaTime' has a wrong offset!");
static_assert(offsetof(AGameNetworkManager, ClientNetSendMoveDeltaTimeThrottled) == 0x00030C, "Member 'AGameNetworkManager::ClientNetSendMoveDeltaTimeThrottled' has a wrong offset!");
static_assert(offsetof(AGameNetworkManager, ClientNetSendMoveDeltaTimeStationary) == 0x000310, "Member 'AGameNetworkManager::ClientNetSendMoveDeltaTimeStationary' has a wrong offset!");
static_assert(offsetof(AGameNetworkManager, ClientNetSendMoveThrottleAtNetSpeed) == 0x000314, "Member 'AGameNetworkManager::ClientNetSendMoveThrottleAtNetSpeed' has a wrong offset!");
static_assert(offsetof(AGameNetworkManager, ClientNetSendMoveThrottleOverPlayerCount) == 0x000318, "Member 'AGameNetworkManager::ClientNetSendMoveThrottleOverPlayerCount' has a wrong offset!");
static_assert(offsetof(AGameNetworkManager, ClientErrorUpdateRateLimit) == 0x00031C, "Member 'AGameNetworkManager::ClientErrorUpdateRateLimit' has a wrong offset!");
static_assert(offsetof(AGameNetworkManager, ClientNetCamUpdateDeltaTime) == 0x000320, "Member 'AGameNetworkManager::ClientNetCamUpdateDeltaTime' has a wrong offset!");
static_assert(offsetof(AGameNetworkManager, ClientNetCamUpdatePositionLimit) == 0x000324, "Member 'AGameNetworkManager::ClientNetCamUpdatePositionLimit' has a wrong offset!");
static_assert(offsetof(AGameNetworkManager, ClientAuthorativePosition) == 0x000328, "Member 'AGameNetworkManager::ClientAuthorativePosition' has a wrong offset!");
static_assert(offsetof(AGameNetworkManager, bMovementTimeDiscrepancyDetection) == 0x000329, "Member 'AGameNetworkManager::bMovementTimeDiscrepancyDetection' has a wrong offset!");
static_assert(offsetof(AGameNetworkManager, bMovementTimeDiscrepancyResolution) == 0x00032A, "Member 'AGameNetworkManager::bMovementTimeDiscrepancyResolution' has a wrong offset!");
static_assert(offsetof(AGameNetworkManager, MovementTimeDiscrepancyMaxTimeMargin) == 0x00032C, "Member 'AGameNetworkManager::MovementTimeDiscrepancyMaxTimeMargin' has a wrong offset!");
static_assert(offsetof(AGameNetworkManager, MovementTimeDiscrepancyMinTimeMargin) == 0x000330, "Member 'AGameNetworkManager::MovementTimeDiscrepancyMinTimeMargin' has a wrong offset!");
static_assert(offsetof(AGameNetworkManager, MovementTimeDiscrepancyResolutionRate) == 0x000334, "Member 'AGameNetworkManager::MovementTimeDiscrepancyResolutionRate' has a wrong offset!");
static_assert(offsetof(AGameNetworkManager, MovementTimeDiscrepancyDriftAllowance) == 0x000338, "Member 'AGameNetworkManager::MovementTimeDiscrepancyDriftAllowance' has a wrong offset!");
static_assert(offsetof(AGameNetworkManager, bMovementTimeDiscrepancyForceCorrectionsDuringResolution) == 0x00033C, "Member 'AGameNetworkManager::bMovementTimeDiscrepancyForceCorrectionsDuringResolution' has a wrong offset!");
static_assert(offsetof(AGameNetworkManager, bUseDistanceBasedRelevancy) == 0x00033D, "Member 'AGameNetworkManager::bUseDistanceBasedRelevancy' has a wrong offset!");

// Class Engine.AudioComponent
// 0x09E0 (0x0C80 - 0x02A0)
class UAudioComponent : public USceneComponent
{
public:
	uint8                                         Pad_2A0[0x1A0];                                    // 0x02A0(0x01A0)(Fixing Size After Last Property [ Dumper-7 ])
	class USoundBase*                             Sound;                                             // 0x0440(0x0008)(Edit, BlueprintVisible, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TArray<struct FAudioParameter>                DefaultParameters;                                 // 0x0448(0x0010)(Edit, BlueprintVisible, ZeroConstructor, NativeAccessSpecifierPublic)
	TArray<struct FAudioParameter>                InstanceParameters;                                // 0x0458(0x0010)(ZeroConstructor, Transient, NativeAccessSpecifierPublic)
	class USoundClass*                            SoundClassOverride;                                // 0x0468(0x0008)(Edit, ZeroConstructor, NoDestructor, AdvancedDisplay, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bAutoDestroy : 1;                                  // 0x0470(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bStopWhenOwnerDestroyed : 1;                       // 0x0470(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bShouldRemainActiveIfDropped : 1;                  // 0x0470(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bAllowSpatialization : 1;                          // 0x0470(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bOverrideAttenuation : 1;                          // 0x0470(0x0001)(BitIndex: 0x04, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bOverrideSubtitlePriority : 1;                     // 0x0470(0x0001)(BitIndex: 0x05, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bIsUISound : 1;                                    // 0x0470(0x0001)(BitIndex: 0x06, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bEnableLowPassFilter : 1;                          // 0x0470(0x0001)(BitIndex: 0x07, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bOverridePriority : 1;                             // 0x0471(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bSuppressSubtitles : 1;                            // 0x0471(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bCanPlayMultipleInstances : 1;                     // 0x0471(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bDisableParameterUpdatesWhilePlaying : 1;          // 0x0471(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         BitPad_471_4 : 4;                                  // 0x0471(0x0001)(Fixing Bit-Field Size For New Byte [ Dumper-7 ])
	uint8                                         BitPad_472_0 : 6;                                  // 0x0472(0x0001)(Fixing Bit-Field Size Between Bits [ Dumper-7 ])
	uint8                                         bAutoManageAttachment : 1;                         // 0x0472(0x0001)(BitIndex: 0x06, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_473[0x5];                                      // 0x0473(0x0005)(Fixing Size After Last Property [ Dumper-7 ])
	class FName                                   AudioComponentUserID;                              // 0x0478(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         PitchModulationMin;                                // 0x0480(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         PitchModulationMax;                                // 0x0484(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         VolumeModulationMin;                               // 0x0488(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         VolumeModulationMax;                               // 0x048C(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         VolumeMultiplier;                                  // 0x0490(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         EnvelopeFollowerAttackTime;                        // 0x0494(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         EnvelopeFollowerReleaseTime;                       // 0x0498(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         Priority;                                          // 0x049C(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         SubtitlePriority;                                  // 0x04A0(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_4A4[0x4];                                      // 0x04A4(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	class USoundEffectSourcePresetChain*          SourceEffectChain;                                 // 0x04A8(0x0008)(Edit, BlueprintVisible, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         PitchMultiplier;                                   // 0x04B0(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         LowPassFilterFrequency;                            // 0x04B4(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_4B8[0x8];                                      // 0x04B8(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	class USoundAttenuation*                      AttenuationSettings;                               // 0x04C0(0x0008)(Edit, BlueprintVisible, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FSoundAttenuationSettings              AttenuationOverrides;                              // 0x04C8(0x03D0)(Edit, BlueprintVisible, NativeAccessSpecifierPublic)
	class USoundConcurrency*                      ConcurrencySettings;                               // 0x0898(0x0008)(ZeroConstructor, Deprecated, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TSet<class USoundConcurrency*>                ConcurrencySet;                                    // 0x08A0(0x0050)(Edit, BlueprintVisible, UObjectWrapper, NativeAccessSpecifierPublic)
	uint8                                         Pad_8F0[0xC];                                      // 0x08F0(0x000C)(Fixing Size After Last Property [ Dumper-7 ])
	EAttachmentRule                               AutoAttachLocationRule;                            // 0x08FC(0x0001)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EAttachmentRule                               AutoAttachRotationRule;                            // 0x08FD(0x0001)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EAttachmentRule                               AutoAttachScaleRule;                               // 0x08FE(0x0001)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_8FF[0x1];                                      // 0x08FF(0x0001)(Fixing Size After Last Property [ Dumper-7 ])
	struct FSoundModulationDefaultRoutingSettings ModulationRouting;                                 // 0x0900(0x0168)(Edit, BlueprintVisible, NativeAccessSpecifierPublic)
	TMulticastInlineDelegate<void(EAudioComponentPlayState PlayState)> OnAudioPlayStateChanged;      // 0x0A68(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	uint8                                         Pad_A78[0x18];                                     // 0x0A78(0x0018)(Fixing Size After Last Property [ Dumper-7 ])
	TMulticastInlineDelegate<void(bool bIsVirtualized)> OnAudioVirtualizationChanged;                // 0x0A90(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	uint8                                         Pad_AA0[0x18];                                     // 0x0AA0(0x0018)(Fixing Size After Last Property [ Dumper-7 ])
	TMulticastInlineDelegate<void()>              OnAudioFinished;                                   // 0x0AB8(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	uint8                                         Pad_AC8[0x18];                                     // 0x0AC8(0x0018)(Fixing Size After Last Property [ Dumper-7 ])
	TMulticastInlineDelegate<void(const class USoundWave* PlayingSoundWave, const float PlaybackPercent)> OnAudioPlaybackPercent; // 0x0AE0(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	uint8                                         Pad_AF0[0x18];                                     // 0x0AF0(0x0018)(Fixing Size After Last Property [ Dumper-7 ])
	TMulticastInlineDelegate<void(const class USoundWave* PlayingSoundWave, const float EnvelopeValue)> OnAudioSingleEnvelopeValue; // 0x0B08(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	uint8                                         Pad_B18[0x18];                                     // 0x0B18(0x0018)(Fixing Size After Last Property [ Dumper-7 ])
	TMulticastInlineDelegate<void(const float AverageEnvelopeValue, const float MaxEnvelope, const int32 NumWaveInstances)> OnAudioMultiEnvelopeValue; // 0x0B30(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	uint8                                         Pad_B40[0x18];                                     // 0x0B40(0x0018)(Fixing Size After Last Property [ Dumper-7 ])
	TDelegate<void(const TArray<struct FSubtitleCue>& Subtitles, float CueDuration)> OnQueueSubtitles; // 0x0B58(0x0010)(ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_B68[0x10];                                     // 0x0B68(0x0010)(Fixing Size After Last Property [ Dumper-7 ])
	TWeakObjectPtr<class USceneComponent>         AutoAttachParent;                                  // 0x0B78(0x0008)(Edit, BlueprintVisible, ExportObject, ZeroConstructor, DisableEditOnTemplate, EditConst, InstancedReference, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FName                                   AutoAttachSocketName;                              // 0x0B80(0x0008)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_B88[0xF8];                                     // 0x0B88(0x00F8)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void AdjustAttenuation(const struct FSoundAttenuationSettings& InAttenuationSettings);
	void AdjustVolume(float AdjustVolumeDuration, float AdjustVolumeLevel, const EAudioFaderCurve FadeCurve);
	bool BP_GetAttenuationSettingsToApply(struct FSoundAttenuationSettings* OutAttenuationSettings);
	void FadeIn(float FadeInDuration, float FadeVolumeLevel, float startTime, const EAudioFaderCurve FadeCurve);
	void FadeOut(float FadeOutDuration, float FadeVolumeLevel, const EAudioFaderCurve FadeCurve);
	bool GetCookedEnvelopeData(float* OutEnvelopeData);
	bool GetCookedEnvelopeDataForAllPlayingSounds(TArray<struct FSoundWaveEnvelopeDataPerSound>* OutEnvelopeData);
	bool GetCookedFFTData(const TArray<float>& FrequenciesToGet, TArray<struct FSoundWaveSpectralData>* OutSoundWaveSpectralData);
	bool GetCookedFFTDataForAllPlayingSounds(TArray<struct FSoundWaveSpectralDataPerSound>* OutSoundWaveSpectralData);
	TSet<class USoundModulatorBase*> GetModulators(const EModulationDestination Destination);
	void Play(float startTime);
	void PlayQuantized(const class UObject* WorldContextObject, class UQuartzClockHandle*& InClockHandle, struct FQuartzQuantizationBoundary& InQuantizationBoundary, const TDelegate<void(EQuartzCommandDelegateSubType EventType, class FName Name)>& InDelegate, float InStartTime, float InFadeInDuration, float InFadeVolumeLevel, EAudioFaderCurve InFadeCurve);
	void SetAudioBusSendPostEffect(class UAudioBus* AudioBus, float AudioBusSendLevel);
	void SetAudioBusSendPreEffect(class UAudioBus* AudioBus, float AudioBusSendLevel);
	void SetBoolParameter(class FName InName, bool InBool);
	void SetFloatParameter(class FName InName, float InFloat);
	void SetIntParameter(class FName InName, int32 inInt);
	void SetLowPassFilterEnabled(bool InLowPassFilterEnabled);
	void SetLowPassFilterFrequency(float InLowPassFilterFrequency);
	void SetModulationRouting(const TSet<class USoundModulatorBase*>& Modulators, const EModulationDestination Destination, const EModulationRouting RoutingMethod);
	void SetOutputToBusOnly(bool bInOutputToBusOnly);
	void SetPaused(bool bPause);
	void SetPitchMultiplier(float NewPitchMultiplier);
	void SetSound(class USoundBase* NewSound);
	void SetSourceBusSendPostEffect(class USoundSourceBus* SoundSourceBus, float SourceBusSendLevel);
	void SetSourceBusSendPreEffect(class USoundSourceBus* SoundSourceBus, float SourceBusSendLevel);
	void SetSubmixSend(class USoundSubmixBase* Submix, float SendLevel);
	void SetUISound(bool bInUISound);
	void SetVolumeMultiplier(float NewVolumeMultiplier);
	void SetWaveParameter(class FName InName, class USoundWave* InWave);
	void Stop();
	void StopDelayed(float DelayTime);

	EAudioComponentPlayState GetPlayState() const;
	bool HasCookedAmplitudeEnvelopeData() const;
	bool HasCookedFFTData() const;
	bool IsPlaying() const;
	bool IsVirtualized() const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AudioComponent">();
	}
	static class UAudioComponent* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAudioComponent>();
	}
};
static_assert(alignof(UAudioComponent) == 0x000010, "Wrong alignment on UAudioComponent");
static_assert(sizeof(UAudioComponent) == 0x000C80, "Wrong size on UAudioComponent");
static_assert(offsetof(UAudioComponent, Sound) == 0x000440, "Member 'UAudioComponent::Sound' has a wrong offset!");
static_assert(offsetof(UAudioComponent, DefaultParameters) == 0x000448, "Member 'UAudioComponent::DefaultParameters' has a wrong offset!");
static_assert(offsetof(UAudioComponent, InstanceParameters) == 0x000458, "Member 'UAudioComponent::InstanceParameters' has a wrong offset!");
static_assert(offsetof(UAudioComponent, SoundClassOverride) == 0x000468, "Member 'UAudioComponent::SoundClassOverride' has a wrong offset!");
static_assert(offsetof(UAudioComponent, AudioComponentUserID) == 0x000478, "Member 'UAudioComponent::AudioComponentUserID' has a wrong offset!");
static_assert(offsetof(UAudioComponent, PitchModulationMin) == 0x000480, "Member 'UAudioComponent::PitchModulationMin' has a wrong offset!");
static_assert(offsetof(UAudioComponent, PitchModulationMax) == 0x000484, "Member 'UAudioComponent::PitchModulationMax' has a wrong offset!");
static_assert(offsetof(UAudioComponent, VolumeModulationMin) == 0x000488, "Member 'UAudioComponent::VolumeModulationMin' has a wrong offset!");
static_assert(offsetof(UAudioComponent, VolumeModulationMax) == 0x00048C, "Member 'UAudioComponent::VolumeModulationMax' has a wrong offset!");
static_assert(offsetof(UAudioComponent, VolumeMultiplier) == 0x000490, "Member 'UAudioComponent::VolumeMultiplier' has a wrong offset!");
static_assert(offsetof(UAudioComponent, EnvelopeFollowerAttackTime) == 0x000494, "Member 'UAudioComponent::EnvelopeFollowerAttackTime' has a wrong offset!");
static_assert(offsetof(UAudioComponent, EnvelopeFollowerReleaseTime) == 0x000498, "Member 'UAudioComponent::EnvelopeFollowerReleaseTime' has a wrong offset!");
static_assert(offsetof(UAudioComponent, Priority) == 0x00049C, "Member 'UAudioComponent::Priority' has a wrong offset!");
static_assert(offsetof(UAudioComponent, SubtitlePriority) == 0x0004A0, "Member 'UAudioComponent::SubtitlePriority' has a wrong offset!");
static_assert(offsetof(UAudioComponent, SourceEffectChain) == 0x0004A8, "Member 'UAudioComponent::SourceEffectChain' has a wrong offset!");
static_assert(offsetof(UAudioComponent, PitchMultiplier) == 0x0004B0, "Member 'UAudioComponent::PitchMultiplier' has a wrong offset!");
static_assert(offsetof(UAudioComponent, LowPassFilterFrequency) == 0x0004B4, "Member 'UAudioComponent::LowPassFilterFrequency' has a wrong offset!");
static_assert(offsetof(UAudioComponent, AttenuationSettings) == 0x0004C0, "Member 'UAudioComponent::AttenuationSettings' has a wrong offset!");
static_assert(offsetof(UAudioComponent, AttenuationOverrides) == 0x0004C8, "Member 'UAudioComponent::AttenuationOverrides' has a wrong offset!");
static_assert(offsetof(UAudioComponent, ConcurrencySettings) == 0x000898, "Member 'UAudioComponent::ConcurrencySettings' has a wrong offset!");
static_assert(offsetof(UAudioComponent, ConcurrencySet) == 0x0008A0, "Member 'UAudioComponent::ConcurrencySet' has a wrong offset!");
static_assert(offsetof(UAudioComponent, AutoAttachLocationRule) == 0x0008FC, "Member 'UAudioComponent::AutoAttachLocationRule' has a wrong offset!");
static_assert(offsetof(UAudioComponent, AutoAttachRotationRule) == 0x0008FD, "Member 'UAudioComponent::AutoAttachRotationRule' has a wrong offset!");
static_assert(offsetof(UAudioComponent, AutoAttachScaleRule) == 0x0008FE, "Member 'UAudioComponent::AutoAttachScaleRule' has a wrong offset!");
static_assert(offsetof(UAudioComponent, ModulationRouting) == 0x000900, "Member 'UAudioComponent::ModulationRouting' has a wrong offset!");
static_assert(offsetof(UAudioComponent, OnAudioPlayStateChanged) == 0x000A68, "Member 'UAudioComponent::OnAudioPlayStateChanged' has a wrong offset!");
static_assert(offsetof(UAudioComponent, OnAudioVirtualizationChanged) == 0x000A90, "Member 'UAudioComponent::OnAudioVirtualizationChanged' has a wrong offset!");
static_assert(offsetof(UAudioComponent, OnAudioFinished) == 0x000AB8, "Member 'UAudioComponent::OnAudioFinished' has a wrong offset!");
static_assert(offsetof(UAudioComponent, OnAudioPlaybackPercent) == 0x000AE0, "Member 'UAudioComponent::OnAudioPlaybackPercent' has a wrong offset!");
static_assert(offsetof(UAudioComponent, OnAudioSingleEnvelopeValue) == 0x000B08, "Member 'UAudioComponent::OnAudioSingleEnvelopeValue' has a wrong offset!");
static_assert(offsetof(UAudioComponent, OnAudioMultiEnvelopeValue) == 0x000B30, "Member 'UAudioComponent::OnAudioMultiEnvelopeValue' has a wrong offset!");
static_assert(offsetof(UAudioComponent, OnQueueSubtitles) == 0x000B58, "Member 'UAudioComponent::OnQueueSubtitles' has a wrong offset!");
static_assert(offsetof(UAudioComponent, AutoAttachParent) == 0x000B78, "Member 'UAudioComponent::AutoAttachParent' has a wrong offset!");
static_assert(offsetof(UAudioComponent, AutoAttachSocketName) == 0x000B80, "Member 'UAudioComponent::AutoAttachSocketName' has a wrong offset!");

// Class Engine.SpotLight
// 0x0008 (0x02B8 - 0x02B0)
class ASpotLight : public ALight
{
public:
	class USpotLightComponent*                    SpotLightComponent;                                // 0x02B0(0x0008)(Edit, BlueprintVisible, ExportObject, BlueprintReadOnly, ZeroConstructor, EditConst, InstancedReference, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)

public:
	void SetInnerConeAngle(float NewInnerConeAngle);
	void SetOuterConeAngle(float NewOuterConeAngle);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"SpotLight">();
	}
	static class ASpotLight* GetDefaultObj()
	{
		return GetDefaultObjImpl<ASpotLight>();
	}
};
static_assert(alignof(ASpotLight) == 0x000008, "Wrong alignment on ASpotLight");
static_assert(sizeof(ASpotLight) == 0x0002B8, "Wrong size on ASpotLight");
static_assert(offsetof(ASpotLight, SpotLightComponent) == 0x0002B0, "Member 'ASpotLight::SpotLightComponent' has a wrong offset!");

// Class Engine.WorldComposition
// 0x0040 (0x0068 - 0x0028)
class UWorldComposition final : public UObject
{
public:
	uint8                                         Pad_28[0x20];                                      // 0x0028(0x0020)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<class ULevelStreaming*>                TilesStreaming;                                    // 0x0048(0x0010)(ZeroConstructor, Transient, UObjectWrapper, NativeAccessSpecifierPublic)
	double                                        TilesStreamingTimeThreshold;                       // 0x0058(0x0008)(ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bLoadAllTilesDuringCinematic;                      // 0x0060(0x0001)(ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bRebaseOriginIn3DSpace;                            // 0x0061(0x0001)(ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_62[0x2];                                       // 0x0062(0x0002)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         RebaseOriginDistance;                              // 0x0064(0x0004)(ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"WorldComposition">();
	}
	static class UWorldComposition* GetDefaultObj()
	{
		return GetDefaultObjImpl<UWorldComposition>();
	}
};
static_assert(alignof(UWorldComposition) == 0x000008, "Wrong alignment on UWorldComposition");
static_assert(sizeof(UWorldComposition) == 0x000068, "Wrong size on UWorldComposition");
static_assert(offsetof(UWorldComposition, TilesStreaming) == 0x000048, "Member 'UWorldComposition::TilesStreaming' has a wrong offset!");
static_assert(offsetof(UWorldComposition, TilesStreamingTimeThreshold) == 0x000058, "Member 'UWorldComposition::TilesStreamingTimeThreshold' has a wrong offset!");
static_assert(offsetof(UWorldComposition, bLoadAllTilesDuringCinematic) == 0x000060, "Member 'UWorldComposition::bLoadAllTilesDuringCinematic' has a wrong offset!");
static_assert(offsetof(UWorldComposition, bRebaseOriginIn3DSpace) == 0x000061, "Member 'UWorldComposition::bRebaseOriginIn3DSpace' has a wrong offset!");
static_assert(offsetof(UWorldComposition, RebaseOriginDistance) == 0x000064, "Member 'UWorldComposition::RebaseOriginDistance' has a wrong offset!");

// Class Engine.MaterialExpressionParticleSpriteRotation
// 0x0000 (0x00B0 - 0x00B0)
class UMaterialExpressionParticleSpriteRotation final : public UMaterialExpression
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionParticleSpriteRotation">();
	}
	static class UMaterialExpressionParticleSpriteRotation* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionParticleSpriteRotation>();
	}
};
static_assert(alignof(UMaterialExpressionParticleSpriteRotation) == 0x000008, "Wrong alignment on UMaterialExpressionParticleSpriteRotation");
static_assert(sizeof(UMaterialExpressionParticleSpriteRotation) == 0x0000B0, "Wrong size on UMaterialExpressionParticleSpriteRotation");

// Class Engine.GeneratedMeshAreaLight
// 0x0000 (0x02B8 - 0x02B8)
class AGeneratedMeshAreaLight final : public ASpotLight
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"GeneratedMeshAreaLight">();
	}
	static class AGeneratedMeshAreaLight* GetDefaultObj()
	{
		return GetDefaultObjImpl<AGeneratedMeshAreaLight>();
	}
};
static_assert(alignof(AGeneratedMeshAreaLight) == 0x000008, "Wrong alignment on AGeneratedMeshAreaLight");
static_assert(sizeof(AGeneratedMeshAreaLight) == 0x0002B8, "Wrong size on AGeneratedMeshAreaLight");

// Class Engine.Commandlet
// 0x0058 (0x0080 - 0x0028)
class UCommandlet : public UObject
{
public:
	class FString                                 HelpDescription;                                   // 0x0028(0x0010)(ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FString                                 HelpUsage;                                         // 0x0038(0x0010)(ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FString                                 HelpWebLink;                                       // 0x0048(0x0010)(ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TArray<class FString>                         HelpParamNames;                                    // 0x0058(0x0010)(ZeroConstructor, NativeAccessSpecifierPublic)
	TArray<class FString>                         HelpParamDescriptions;                             // 0x0068(0x0010)(ZeroConstructor, NativeAccessSpecifierPublic)
	uint8                                         IsServer : 1;                                      // 0x0078(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         IsClient : 1;                                      // 0x0078(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         IsEditor : 1;                                      // 0x0078(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         LogToConsole : 1;                                  // 0x0078(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         ShowErrorCount : 1;                                // 0x0078(0x0001)(BitIndex: 0x04, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         ShowProgress : 1;                                  // 0x0078(0x0001)(BitIndex: 0x05, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         FastExit : 1;                                      // 0x0078(0x0001)(BitIndex: 0x06, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         UseCommandletResultAsExitCode : 1;                 // 0x0078(0x0001)(BitIndex: 0x07, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_79[0x7];                                       // 0x0079(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"Commandlet">();
	}
	static class UCommandlet* GetDefaultObj()
	{
		return GetDefaultObjImpl<UCommandlet>();
	}
};
static_assert(alignof(UCommandlet) == 0x000008, "Wrong alignment on UCommandlet");
static_assert(sizeof(UCommandlet) == 0x000080, "Wrong size on UCommandlet");
static_assert(offsetof(UCommandlet, HelpDescription) == 0x000028, "Member 'UCommandlet::HelpDescription' has a wrong offset!");
static_assert(offsetof(UCommandlet, HelpUsage) == 0x000038, "Member 'UCommandlet::HelpUsage' has a wrong offset!");
static_assert(offsetof(UCommandlet, HelpWebLink) == 0x000048, "Member 'UCommandlet::HelpWebLink' has a wrong offset!");
static_assert(offsetof(UCommandlet, HelpParamNames) == 0x000058, "Member 'UCommandlet::HelpParamNames' has a wrong offset!");
static_assert(offsetof(UCommandlet, HelpParamDescriptions) == 0x000068, "Member 'UCommandlet::HelpParamDescriptions' has a wrong offset!");

// Class Engine.PluginCommandlet
// 0x0020 (0x00A0 - 0x0080)
class UPluginCommandlet final : public UCommandlet
{
public:
	uint8                                         Pad_80[0x20];                                      // 0x0080(0x0020)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"PluginCommandlet">();
	}
	static class UPluginCommandlet* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPluginCommandlet>();
	}
};
static_assert(alignof(UPluginCommandlet) == 0x000008, "Wrong alignment on UPluginCommandlet");
static_assert(sizeof(UPluginCommandlet) == 0x0000A0, "Wrong size on UPluginCommandlet");

// Class Engine.HapticFeedbackEffect_Base
// 0x0000 (0x0028 - 0x0028)
class UHapticFeedbackEffect_Base : public UObject
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"HapticFeedbackEffect_Base">();
	}
	static class UHapticFeedbackEffect_Base* GetDefaultObj()
	{
		return GetDefaultObjImpl<UHapticFeedbackEffect_Base>();
	}
};
static_assert(alignof(UHapticFeedbackEffect_Base) == 0x000008, "Wrong alignment on UHapticFeedbackEffect_Base");
static_assert(sizeof(UHapticFeedbackEffect_Base) == 0x000028, "Wrong size on UHapticFeedbackEffect_Base");

// Class Engine.HapticFeedbackEffect_Buffer
// 0x0018 (0x0040 - 0x0028)
class UHapticFeedbackEffect_Buffer final : public UHapticFeedbackEffect_Base
{
public:
	TArray<uint8>                                 Amplitudes;                                        // 0x0028(0x0010)(Edit, ZeroConstructor, NativeAccessSpecifierPublic)
	int32                                         SampleRate;                                        // 0x0038(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_3C[0x4];                                       // 0x003C(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"HapticFeedbackEffect_Buffer">();
	}
	static class UHapticFeedbackEffect_Buffer* GetDefaultObj()
	{
		return GetDefaultObjImpl<UHapticFeedbackEffect_Buffer>();
	}
};
static_assert(alignof(UHapticFeedbackEffect_Buffer) == 0x000008, "Wrong alignment on UHapticFeedbackEffect_Buffer");
static_assert(sizeof(UHapticFeedbackEffect_Buffer) == 0x000040, "Wrong size on UHapticFeedbackEffect_Buffer");
static_assert(offsetof(UHapticFeedbackEffect_Buffer, Amplitudes) == 0x000028, "Member 'UHapticFeedbackEffect_Buffer::Amplitudes' has a wrong offset!");
static_assert(offsetof(UHapticFeedbackEffect_Buffer, SampleRate) == 0x000038, "Member 'UHapticFeedbackEffect_Buffer::SampleRate' has a wrong offset!");

// Class Engine.MaterialExpressionParticleColor
// 0x0000 (0x00B0 - 0x00B0)
class UMaterialExpressionParticleColor final : public UMaterialExpression
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionParticleColor">();
	}
	static class UMaterialExpressionParticleColor* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionParticleColor>();
	}
};
static_assert(alignof(UMaterialExpressionParticleColor) == 0x000008, "Wrong alignment on UMaterialExpressionParticleColor");
static_assert(sizeof(UMaterialExpressionParticleColor) == 0x0000B0, "Wrong size on UMaterialExpressionParticleColor");

// Class Engine.ParticleModuleAttractorPoint
// 0x00C8 (0x00F8 - 0x0030)
class UParticleModuleAttractorPoint final : public UParticleModuleAttractorBase
{
public:
	struct FRawDistributionVector                 position;                                          // 0x0030(0x0060)(Edit, ContainsInstancedReference, NativeAccessSpecifierPublic)
	struct FRawDistributionFloat                  Range;                                             // 0x0090(0x0030)(Edit, ContainsInstancedReference, NativeAccessSpecifierPublic)
	struct FRawDistributionFloat                  Strength;                                          // 0x00C0(0x0030)(Edit, ContainsInstancedReference, NativeAccessSpecifierPublic)
	uint8                                         StrengthByDistance : 1;                            // 0x00F0(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bAffectBaseVelocity : 1;                           // 0x00F0(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bOverrideVelocity : 1;                             // 0x00F0(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bUseWorldSpacePosition : 1;                        // 0x00F0(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Positive_X : 1;                                    // 0x00F0(0x0001)(BitIndex: 0x04, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Positive_Y : 1;                                    // 0x00F0(0x0001)(BitIndex: 0x05, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Positive_Z : 1;                                    // 0x00F0(0x0001)(BitIndex: 0x06, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Negative_X : 1;                                    // 0x00F0(0x0001)(BitIndex: 0x07, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Negative_Y : 1;                                    // 0x00F1(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Negative_Z : 1;                                    // 0x00F1(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_F2[0x6];                                       // 0x00F2(0x0006)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ParticleModuleAttractorPoint">();
	}
	static class UParticleModuleAttractorPoint* GetDefaultObj()
	{
		return GetDefaultObjImpl<UParticleModuleAttractorPoint>();
	}
};
static_assert(alignof(UParticleModuleAttractorPoint) == 0x000008, "Wrong alignment on UParticleModuleAttractorPoint");
static_assert(sizeof(UParticleModuleAttractorPoint) == 0x0000F8, "Wrong size on UParticleModuleAttractorPoint");
static_assert(offsetof(UParticleModuleAttractorPoint, position) == 0x000030, "Member 'UParticleModuleAttractorPoint::position' has a wrong offset!");
static_assert(offsetof(UParticleModuleAttractorPoint, Range) == 0x000090, "Member 'UParticleModuleAttractorPoint::Range' has a wrong offset!");
static_assert(offsetof(UParticleModuleAttractorPoint, Strength) == 0x0000C0, "Member 'UParticleModuleAttractorPoint::Strength' has a wrong offset!");

// Class Engine.HapticFeedbackEffect_Curve
// 0x0110 (0x0138 - 0x0028)
class UHapticFeedbackEffect_Curve final : public UHapticFeedbackEffect_Base
{
public:
	struct FHapticFeedbackDetails_Curve           HapticDetails;                                     // 0x0028(0x0110)(Edit, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"HapticFeedbackEffect_Curve">();
	}
	static class UHapticFeedbackEffect_Curve* GetDefaultObj()
	{
		return GetDefaultObjImpl<UHapticFeedbackEffect_Curve>();
	}
};
static_assert(alignof(UHapticFeedbackEffect_Curve) == 0x000008, "Wrong alignment on UHapticFeedbackEffect_Curve");
static_assert(sizeof(UHapticFeedbackEffect_Curve) == 0x000138, "Wrong size on UHapticFeedbackEffect_Curve");
static_assert(offsetof(UHapticFeedbackEffect_Curve, HapticDetails) == 0x000028, "Member 'UHapticFeedbackEffect_Curve::HapticDetails' has a wrong offset!");

// Class Engine.CameraShakePattern
// 0x0000 (0x0028 - 0x0028)
class UCameraShakePattern : public UObject
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"CameraShakePattern">();
	}
	static class UCameraShakePattern* GetDefaultObj()
	{
		return GetDefaultObjImpl<UCameraShakePattern>();
	}
};
static_assert(alignof(UCameraShakePattern) == 0x000008, "Wrong alignment on UCameraShakePattern");
static_assert(sizeof(UCameraShakePattern) == 0x000028, "Wrong size on UCameraShakePattern");

// Class Engine.ParticleModuleCollisionBase
// 0x0000 (0x0030 - 0x0030)
class UParticleModuleCollisionBase : public UParticleModule
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ParticleModuleCollisionBase">();
	}
	static class UParticleModuleCollisionBase* GetDefaultObj()
	{
		return GetDefaultObjImpl<UParticleModuleCollisionBase>();
	}
};
static_assert(alignof(UParticleModuleCollisionBase) == 0x000008, "Wrong alignment on UParticleModuleCollisionBase");
static_assert(sizeof(UParticleModuleCollisionBase) == 0x000030, "Wrong size on UParticleModuleCollisionBase");

// Class Engine.HapticFeedbackEffect_SoundWave
// 0x0020 (0x0048 - 0x0028)
class UHapticFeedbackEffect_SoundWave final : public UHapticFeedbackEffect_Base
{
public:
	class USoundWave*                             SoundWave;                                         // 0x0028(0x0008)(Edit, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bUseStereo;                                        // 0x0030(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_31[0x17];                                      // 0x0031(0x0017)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"HapticFeedbackEffect_SoundWave">();
	}
	static class UHapticFeedbackEffect_SoundWave* GetDefaultObj()
	{
		return GetDefaultObjImpl<UHapticFeedbackEffect_SoundWave>();
	}
};
static_assert(alignof(UHapticFeedbackEffect_SoundWave) == 0x000008, "Wrong alignment on UHapticFeedbackEffect_SoundWave");
static_assert(sizeof(UHapticFeedbackEffect_SoundWave) == 0x000048, "Wrong size on UHapticFeedbackEffect_SoundWave");
static_assert(offsetof(UHapticFeedbackEffect_SoundWave, SoundWave) == 0x000028, "Member 'UHapticFeedbackEffect_SoundWave::SoundWave' has a wrong offset!");
static_assert(offsetof(UHapticFeedbackEffect_SoundWave, bUseStereo) == 0x000030, "Member 'UHapticFeedbackEffect_SoundWave::bUseStereo' has a wrong offset!");

// Class Engine.MaterialExpressionSparseVolumeTextureBase
// 0x0008 (0x00B8 - 0x00B0)
class UMaterialExpressionSparseVolumeTextureBase : public UMaterialExpression
{
public:
	class USparseVolumeTexture*                   SparseVolumeTexture;                               // 0x00B0(0x0008)(Edit, BlueprintVisible, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionSparseVolumeTextureBase">();
	}
	static class UMaterialExpressionSparseVolumeTextureBase* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionSparseVolumeTextureBase>();
	}
};
static_assert(alignof(UMaterialExpressionSparseVolumeTextureBase) == 0x000008, "Wrong alignment on UMaterialExpressionSparseVolumeTextureBase");
static_assert(sizeof(UMaterialExpressionSparseVolumeTextureBase) == 0x0000B8, "Wrong size on UMaterialExpressionSparseVolumeTextureBase");
static_assert(offsetof(UMaterialExpressionSparseVolumeTextureBase, SparseVolumeTexture) == 0x0000B0, "Member 'UMaterialExpressionSparseVolumeTextureBase::SparseVolumeTexture' has a wrong offset!");

// Class Engine.WorldPartitionHLODSourceActors
// 0x0000 (0x0028 - 0x0028)
class UWorldPartitionHLODSourceActors : public UObject
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"WorldPartitionHLODSourceActors">();
	}
	static class UWorldPartitionHLODSourceActors* GetDefaultObj()
	{
		return GetDefaultObjImpl<UWorldPartitionHLODSourceActors>();
	}
};
static_assert(alignof(UWorldPartitionHLODSourceActors) == 0x000008, "Wrong alignment on UWorldPartitionHLODSourceActors");
static_assert(sizeof(UWorldPartitionHLODSourceActors) == 0x000028, "Wrong size on UWorldPartitionHLODSourceActors");

// Class Engine.CheatManager
// 0x0060 (0x0088 - 0x0028)
class UCheatManager final : public UObject
{
public:
	class ADebugCameraController*                 DebugCameraControllerRef;                          // 0x0028(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TSubclassOf<class ADebugCameraController>     DebugCameraControllerClass;                        // 0x0030(0x0008)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, DisableEditOnInstance, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_38[0x40];                                      // 0x0038(0x0040)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<class UCheatManagerExtension*>         CheatManagerExtensions;                            // 0x0078(0x0010)(ZeroConstructor, Transient, Protected, UObjectWrapper, NativeAccessSpecifierProtected)

public:
	void BugIt(const class FString& ScreenShotDescription);
	void BugItGo(float X, float Y, float Z, float Pitch, float Yaw, float ROLL);
	void BugItStringCreator(const struct FVector& ViewLocation, const struct FRotator& ViewRotation, class FString* GoString, class FString* LocString);
	void ChangeSize(float F);
	void CheatScript(const class FString& ScriptName);
	void DamageTarget(float DamageAmount);
	void DebugCapsuleSweep();
	void DebugCapsuleSweepCapture();
	void DebugCapsuleSweepChannel(ECollisionChannel Channel);
	void DebugCapsuleSweepClear();
	void DebugCapsuleSweepComplex(bool bTraceComplex);
	void DebugCapsuleSweepPawn();
	void DebugCapsuleSweepSize(float HalfHeight, float Radius);
	void DestroyAll(TSubclassOf<class AActor> aClass);
	void DestroyAllPawnsExceptTarget();
	void DestroyPawns(TSubclassOf<class APawn> aClass);
	void DestroyServerStatReplicator();
	void DestroyTarget();
	void DisableDebugCamera();
	void DumpChatState();
	void DumpOnlineSessionState();
	void DumpPartyState();
	void DumpVoiceMutingState();
	void EnableDebugCamera();
	void FlushLog();
	void Fly();
	void FreezeFrame(float Delay);
	void Ghost();
	void God();
	void InvertMouse();
	void LogLoc();
	void OnlyLoadLevel(class FName PackageName);
	void OnPlayerEndPlayed(class AActor* Player, EEndPlayReason EndPlayReason);
	void PlayersOnly();
	void ReceiveEndPlay();
	void ReceiveInitCheatManager();
	void ServerToggleAILogging();
	void SetMouseSensitivityToDefault();
	void SetWorldOrigin();
	void Slomo(float NewTimeDilation);
	void SpawnServerStatReplicator();
	void StreamLevelIn(class FName PackageName);
	void StreamLevelOut(class FName PackageName);
	void Summon(const class FString& ClassName);
	void Teleport();
	void TestCollisionDistance();
	void ToggleAILogging();
	void ToggleDebugCamera();
	void ToggleServerStatReplicatorClientOverwrite();
	void ToggleServerStatReplicatorUpdateStatNet();
	void UpdateSafeArea();
	void ViewActor(class FName ActorName);
	void ViewClass(TSubclassOf<class AActor> DesiredClass);
	void ViewPlayer(const class FString& S);
	void ViewSelf();
	void Walk();

	class APlayerController* GetPlayerController() const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"CheatManager">();
	}
	static class UCheatManager* GetDefaultObj()
	{
		return GetDefaultObjImpl<UCheatManager>();
	}
};
static_assert(alignof(UCheatManager) == 0x000008, "Wrong alignment on UCheatManager");
static_assert(sizeof(UCheatManager) == 0x000088, "Wrong size on UCheatManager");
static_assert(offsetof(UCheatManager, DebugCameraControllerRef) == 0x000028, "Member 'UCheatManager::DebugCameraControllerRef' has a wrong offset!");
static_assert(offsetof(UCheatManager, DebugCameraControllerClass) == 0x000030, "Member 'UCheatManager::DebugCameraControllerClass' has a wrong offset!");
static_assert(offsetof(UCheatManager, CheatManagerExtensions) == 0x000078, "Member 'UCheatManager::CheatManagerExtensions' has a wrong offset!");

// Class Engine.MaterialExpressionMaterialFunctionCall
// 0x0038 (0x00E8 - 0x00B0)
class UMaterialExpressionMaterialFunctionCall final : public UMaterialExpression
{
public:
	class UMaterialFunctionInterface*             MaterialFunction;                                  // 0x00B0(0x0008)(Edit, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TArray<struct FFunctionExpressionInput>       FunctionInputs;                                    // 0x00B8(0x0010)(ZeroConstructor, NativeAccessSpecifierPublic)
	TArray<struct FFunctionExpressionOutput>      FunctionOutputs;                                   // 0x00C8(0x0010)(ZeroConstructor, NativeAccessSpecifierPublic)
	struct FMaterialParameterInfo                 FunctionParameterInfo;                             // 0x00D8(0x0010)(Transient, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionMaterialFunctionCall">();
	}
	static class UMaterialExpressionMaterialFunctionCall* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionMaterialFunctionCall>();
	}
};
static_assert(alignof(UMaterialExpressionMaterialFunctionCall) == 0x000008, "Wrong alignment on UMaterialExpressionMaterialFunctionCall");
static_assert(sizeof(UMaterialExpressionMaterialFunctionCall) == 0x0000E8, "Wrong size on UMaterialExpressionMaterialFunctionCall");
static_assert(offsetof(UMaterialExpressionMaterialFunctionCall, MaterialFunction) == 0x0000B0, "Member 'UMaterialExpressionMaterialFunctionCall::MaterialFunction' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionMaterialFunctionCall, FunctionInputs) == 0x0000B8, "Member 'UMaterialExpressionMaterialFunctionCall::FunctionInputs' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionMaterialFunctionCall, FunctionOutputs) == 0x0000C8, "Member 'UMaterialExpressionMaterialFunctionCall::FunctionOutputs' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionMaterialFunctionCall, FunctionParameterInfo) == 0x0000D8, "Member 'UMaterialExpressionMaterialFunctionCall::FunctionParameterInfo' has a wrong offset!");

// Class Engine.WorldPartitionHLODSourceActorsFromCell
// 0x0000 (0x0028 - 0x0028)
class UWorldPartitionHLODSourceActorsFromCell final : public UWorldPartitionHLODSourceActors
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"WorldPartitionHLODSourceActorsFromCell">();
	}
	static class UWorldPartitionHLODSourceActorsFromCell* GetDefaultObj()
	{
		return GetDefaultObjImpl<UWorldPartitionHLODSourceActorsFromCell>();
	}
};
static_assert(alignof(UWorldPartitionHLODSourceActorsFromCell) == 0x000008, "Wrong alignment on UWorldPartitionHLODSourceActorsFromCell");
static_assert(sizeof(UWorldPartitionHLODSourceActorsFromCell) == 0x000028, "Wrong size on UWorldPartitionHLODSourceActorsFromCell");

// Class Engine.NavMovementComponent
// 0x0048 (0x0158 - 0x0110)
class UNavMovementComponent : public UMovementComponent
{
public:
	struct FNavAgentProperties                    NavAgentProps;                                     // 0x0110(0x0038)(Edit, BlueprintVisible, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         FixedPathBrakingDistance;                          // 0x0148(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         bUpdateNavAgentWithOwnersCollision : 1;            // 0x014C(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
	uint8                                         bUseAccelerationForPaths : 1;                      // 0x014C(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, Config, GlobalConfig, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
	uint8                                         bUseFixedBrakingDistanceForPaths : 1;              // 0x014C(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Edit, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
	struct FMovementProperties                    MovementState;                                     // 0x014D(0x0001)(NoDestructor, NativeAccessSpecifierPublic)
	uint8                                         Pad_14E[0x2];                                      // 0x014E(0x0002)(Fixing Size After Last Property [ Dumper-7 ])
	class UObject*                                PathFollowingComp;                                 // 0x0150(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)

public:
	void StopActiveMovement();
	void StopMovementKeepPathing();

	bool IsCrouching() const;
	bool IsFalling() const;
	bool IsFlying() const;
	bool IsMovingOnGround() const;
	bool IsSwimming() const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"NavMovementComponent">();
	}
	static class UNavMovementComponent* GetDefaultObj()
	{
		return GetDefaultObjImpl<UNavMovementComponent>();
	}
};
static_assert(alignof(UNavMovementComponent) == 0x000008, "Wrong alignment on UNavMovementComponent");
static_assert(sizeof(UNavMovementComponent) == 0x000158, "Wrong size on UNavMovementComponent");
static_assert(offsetof(UNavMovementComponent, NavAgentProps) == 0x000110, "Member 'UNavMovementComponent::NavAgentProps' has a wrong offset!");
static_assert(offsetof(UNavMovementComponent, FixedPathBrakingDistance) == 0x000148, "Member 'UNavMovementComponent::FixedPathBrakingDistance' has a wrong offset!");
static_assert(offsetof(UNavMovementComponent, MovementState) == 0x00014D, "Member 'UNavMovementComponent::MovementState' has a wrong offset!");
static_assert(offsetof(UNavMovementComponent, PathFollowingComp) == 0x000150, "Member 'UNavMovementComponent::PathFollowingComp' has a wrong offset!");

// Class Engine.WorldPartitionHLODSourceActorsFromLevel
// 0x0000 (0x0028 - 0x0028)
class UWorldPartitionHLODSourceActorsFromLevel final : public UWorldPartitionHLODSourceActors
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"WorldPartitionHLODSourceActorsFromLevel">();
	}
	static class UWorldPartitionHLODSourceActorsFromLevel* GetDefaultObj()
	{
		return GetDefaultObjImpl<UWorldPartitionHLODSourceActorsFromLevel>();
	}
};
static_assert(alignof(UWorldPartitionHLODSourceActorsFromLevel) == 0x000008, "Wrong alignment on UWorldPartitionHLODSourceActorsFromLevel");
static_assert(sizeof(UWorldPartitionHLODSourceActorsFromLevel) == 0x000028, "Wrong size on UWorldPartitionHLODSourceActorsFromLevel");

// Class Engine.WorldDataLayers
// 0x0328 (0x05C8 - 0x02A0)
class AWorldDataLayers final : public AInfo
{
public:
	uint8                                         Pad_2A0[0xA0];                                     // 0x02A0(0x00A0)(Fixing Size After Last Property [ Dumper-7 ])
	TSet<class UDataLayerInstance*>               DataLayerInstances;                                // 0x0340(0x0050)(UObjectWrapper, NativeAccessSpecifierPrivate)
	TMap<class FName, TWeakObjectPtr<class UDataLayerInstance>> DeprecatedDataLayerNameToDataLayerInstance; // 0x0390(0x0050)(UObjectWrapper, NativeAccessSpecifierPrivate)
	TSet<class UDataLayer*>                       WorldDataLayers;                                   // 0x03E0(0x0050)(Deprecated, UObjectWrapper, NativeAccessSpecifierPrivate)
	TArray<class FName>                           RepActiveDataLayerNames;                           // 0x0430(0x0010)(Net, ZeroConstructor, Transient, RepNotify, NativeAccessSpecifierPrivate)
	TArray<class FName>                           RepLoadedDataLayerNames;                           // 0x0440(0x0010)(Net, ZeroConstructor, Transient, RepNotify, NativeAccessSpecifierPrivate)
	uint8                                         Pad_450[0xA0];                                     // 0x0450(0x00A0)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<class FName>                           RepEffectiveActiveDataLayerNames;                  // 0x04F0(0x0010)(Net, ZeroConstructor, Transient, RepNotify, NativeAccessSpecifierPrivate)
	TArray<class FName>                           RepEffectiveLoadedDataLayerNames;                  // 0x0500(0x0010)(Net, ZeroConstructor, Transient, RepNotify, NativeAccessSpecifierPrivate)
	uint8                                         Pad_510[0xB8];                                     // 0x0510(0x00B8)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void OnDataLayerRuntimeStateChanged(const class UDataLayerInstance* InDataLayer, EDataLayerRuntimeState InState);
	void OnRep_ActiveDataLayerNames();
	void OnRep_EffectiveActiveDataLayerNames();
	void OnRep_EffectiveLoadedDataLayerNames();
	void OnRep_LoadedDataLayerNames();

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"WorldDataLayers">();
	}
	static class AWorldDataLayers* GetDefaultObj()
	{
		return GetDefaultObjImpl<AWorldDataLayers>();
	}
};
static_assert(alignof(AWorldDataLayers) == 0x000008, "Wrong alignment on AWorldDataLayers");
static_assert(sizeof(AWorldDataLayers) == 0x0005C8, "Wrong size on AWorldDataLayers");
static_assert(offsetof(AWorldDataLayers, DataLayerInstances) == 0x000340, "Member 'AWorldDataLayers::DataLayerInstances' has a wrong offset!");
static_assert(offsetof(AWorldDataLayers, DeprecatedDataLayerNameToDataLayerInstance) == 0x000390, "Member 'AWorldDataLayers::DeprecatedDataLayerNameToDataLayerInstance' has a wrong offset!");
static_assert(offsetof(AWorldDataLayers, WorldDataLayers) == 0x0003E0, "Member 'AWorldDataLayers::WorldDataLayers' has a wrong offset!");
static_assert(offsetof(AWorldDataLayers, RepActiveDataLayerNames) == 0x000430, "Member 'AWorldDataLayers::RepActiveDataLayerNames' has a wrong offset!");
static_assert(offsetof(AWorldDataLayers, RepLoadedDataLayerNames) == 0x000440, "Member 'AWorldDataLayers::RepLoadedDataLayerNames' has a wrong offset!");
static_assert(offsetof(AWorldDataLayers, RepEffectiveActiveDataLayerNames) == 0x0004F0, "Member 'AWorldDataLayers::RepEffectiveActiveDataLayerNames' has a wrong offset!");
static_assert(offsetof(AWorldDataLayers, RepEffectiveLoadedDataLayerNames) == 0x000500, "Member 'AWorldDataLayers::RepEffectiveLoadedDataLayerNames' has a wrong offset!");

// Class Engine.MaterialExpressionFresnel
// 0x0088 (0x0138 - 0x00B0)
class UMaterialExpressionFresnel final : public UMaterialExpression
{
public:
	struct FExpressionInput                       ExponentIn;                                        // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	float                                         Exponent;                                          // 0x00D8(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_DC[0x4];                                       // 0x00DC(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	struct FExpressionInput                       BaseReflectFractionIn;                             // 0x00E0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	float                                         BaseReflectFraction;                               // 0x0108(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_10C[0x4];                                      // 0x010C(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	struct FExpressionInput                       Normal;                                            // 0x0110(0x0028)(NoDestructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionFresnel">();
	}
	static class UMaterialExpressionFresnel* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionFresnel>();
	}
};
static_assert(alignof(UMaterialExpressionFresnel) == 0x000008, "Wrong alignment on UMaterialExpressionFresnel");
static_assert(sizeof(UMaterialExpressionFresnel) == 0x000138, "Wrong size on UMaterialExpressionFresnel");
static_assert(offsetof(UMaterialExpressionFresnel, ExponentIn) == 0x0000B0, "Member 'UMaterialExpressionFresnel::ExponentIn' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionFresnel, Exponent) == 0x0000D8, "Member 'UMaterialExpressionFresnel::Exponent' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionFresnel, BaseReflectFractionIn) == 0x0000E0, "Member 'UMaterialExpressionFresnel::BaseReflectFractionIn' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionFresnel, BaseReflectFraction) == 0x000108, "Member 'UMaterialExpressionFresnel::BaseReflectFraction' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionFresnel, Normal) == 0x000110, "Member 'UMaterialExpressionFresnel::Normal' has a wrong offset!");

// Class Engine.HLODTemplatedInstancedStaticMeshComponent
// 0x0010 (0x07A0 - 0x0790)
class UHLODTemplatedInstancedStaticMeshComponent final : public UInstancedStaticMeshComponent
{
public:
	TSubclassOf<class AActor>                     TemplateActorClass;                                // 0x0788(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	class FName                                   TemplateComponentName;                             // 0x0790(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_798[0x8];                                      // 0x0798(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"HLODTemplatedInstancedStaticMeshComponent">();
	}
	static class UHLODTemplatedInstancedStaticMeshComponent* GetDefaultObj()
	{
		return GetDefaultObjImpl<UHLODTemplatedInstancedStaticMeshComponent>();
	}
};
static_assert(alignof(UHLODTemplatedInstancedStaticMeshComponent) == 0x000010, "Wrong alignment on UHLODTemplatedInstancedStaticMeshComponent");
static_assert(sizeof(UHLODTemplatedInstancedStaticMeshComponent) == 0x0007A0, "Wrong size on UHLODTemplatedInstancedStaticMeshComponent");
static_assert(offsetof(UHLODTemplatedInstancedStaticMeshComponent, TemplateActorClass) == 0x000788, "Member 'UHLODTemplatedInstancedStaticMeshComponent::TemplateActorClass' has a wrong offset!");
static_assert(offsetof(UHLODTemplatedInstancedStaticMeshComponent, TemplateComponentName) == 0x000790, "Member 'UHLODTemplatedInstancedStaticMeshComponent::TemplateComponentName' has a wrong offset!");

// Class Engine.BoundsCopyComponent
// 0x00A8 (0x0150 - 0x00A8)
class UBoundsCopyComponent final : public UActorComponent
{
public:
	TSoftObjectPtr<class AActor>                  BoundsSourceActor;                                 // 0x00A8(0x0028)(Edit, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bUseCollidingComponentsForSourceBounds;            // 0x00D0(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bKeepOwnBoundsScale;                               // 0x00D1(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bUseCollidingComponentsForOwnBounds;               // 0x00D2(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_D3[0xD];                                       // 0x00D3(0x000D)(Fixing Size After Last Property [ Dumper-7 ])
	struct FTransform                             PostTransform;                                     // 0x00E0(0x0060)(IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bCopyXBounds;                                      // 0x0140(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bCopyYBounds;                                      // 0x0141(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bCopyZBounds;                                      // 0x0142(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_143[0xD];                                      // 0x0143(0x000D)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"BoundsCopyComponent">();
	}
	static class UBoundsCopyComponent* GetDefaultObj()
	{
		return GetDefaultObjImpl<UBoundsCopyComponent>();
	}
};
static_assert(alignof(UBoundsCopyComponent) == 0x000010, "Wrong alignment on UBoundsCopyComponent");
static_assert(sizeof(UBoundsCopyComponent) == 0x000150, "Wrong size on UBoundsCopyComponent");
static_assert(offsetof(UBoundsCopyComponent, BoundsSourceActor) == 0x0000A8, "Member 'UBoundsCopyComponent::BoundsSourceActor' has a wrong offset!");
static_assert(offsetof(UBoundsCopyComponent, bUseCollidingComponentsForSourceBounds) == 0x0000D0, "Member 'UBoundsCopyComponent::bUseCollidingComponentsForSourceBounds' has a wrong offset!");
static_assert(offsetof(UBoundsCopyComponent, bKeepOwnBoundsScale) == 0x0000D1, "Member 'UBoundsCopyComponent::bKeepOwnBoundsScale' has a wrong offset!");
static_assert(offsetof(UBoundsCopyComponent, bUseCollidingComponentsForOwnBounds) == 0x0000D2, "Member 'UBoundsCopyComponent::bUseCollidingComponentsForOwnBounds' has a wrong offset!");
static_assert(offsetof(UBoundsCopyComponent, PostTransform) == 0x0000E0, "Member 'UBoundsCopyComponent::PostTransform' has a wrong offset!");
static_assert(offsetof(UBoundsCopyComponent, bCopyXBounds) == 0x000140, "Member 'UBoundsCopyComponent::bCopyXBounds' has a wrong offset!");
static_assert(offsetof(UBoundsCopyComponent, bCopyYBounds) == 0x000141, "Member 'UBoundsCopyComponent::bCopyYBounds' has a wrong offset!");
static_assert(offsetof(UBoundsCopyComponent, bCopyZBounds) == 0x000142, "Member 'UBoundsCopyComponent::bCopyZBounds' has a wrong offset!");

// Class Engine.AnimationDataController
// 0x0000 (0x0000 - 0x0000)
class IAnimationDataController final
{
public:
	bool AddAttribute(const struct FAnimationAttributeIdentifier& AttributeIdentifier, bool bShouldTransact);
	bool AddBoneCurve(class FName BoneName, bool bShouldTransact);
	int32 AddBoneTrack(class FName BoneName, bool bShouldTransact);
	bool AddCurve(const struct FAnimationCurveIdentifier& CurveId, int32 CurveFlags, bool bShouldTransact);
	void CloseBracket(bool bShouldTransact);
	bool DuplicateAttribute(const struct FAnimationAttributeIdentifier& AttributeIdentifier, const struct FAnimationAttributeIdentifier& NewAttributeIdentifier, bool bShouldTransact);
	bool DuplicateCurve(const struct FAnimationCurveIdentifier& CopyCurveId, const struct FAnimationCurveIdentifier& NewCurveId, bool bShouldTransact);
	void FindOrAddCurveNamesOnSkeleton(class USkeleton* Skeleton, ERawCurveTrackTypes SupportedCurveType, bool bShouldTransact);
	int32 InsertBoneTrack(class FName BoneName, int32 DesiredIndex, bool bShouldTransact);
	void OpenBracket(const class FText& InTitle, bool bShouldTransact);
	int32 RemoveAllAttributes(bool bShouldTransact);
	int32 RemoveAllAttributesForBone(const class FName& BoneName, bool bShouldTransact);
	void RemoveAllBoneTracks(bool bShouldTransact);
	void RemoveAllCurvesOfType(ERawCurveTrackTypes SupportedCurveType, bool bShouldTransact);
	bool RemoveAttribute(const struct FAnimationAttributeIdentifier& AttributeIdentifier, bool bShouldTransact);
	bool RemoveAttributeKey(const struct FAnimationAttributeIdentifier& AttributeIdentifier, float Time, bool bShouldTransact);
	bool RemoveBoneTrack(class FName BoneName, bool bShouldTransact);
	bool RemoveCurve(const struct FAnimationCurveIdentifier& CurveId, bool bShouldTransact);
	bool RemoveCurveKey(const struct FAnimationCurveIdentifier& CurveId, float Time, bool bShouldTransact);
	bool RemoveTransformCurveKey(const struct FAnimationCurveIdentifier& CurveId, float Time, bool bShouldTransact);
	bool RenameCurve(const struct FAnimationCurveIdentifier& CurveToRenameId, const struct FAnimationCurveIdentifier& NewCurveId, bool bShouldTransact);
	void Resize(float Length, float t0, float T1, bool bShouldTransact);
	void ResizeInFrames(const struct FFrameNumber& NewLengthInFrames, const struct FFrameNumber& t0, const struct FFrameNumber& T1, bool bShouldTransact);
	void ResizeNumberOfFrames(const struct FFrameNumber& NewLengthInFrames, const struct FFrameNumber& t0, const struct FFrameNumber& T1, bool bShouldTransact);
	void ResizePlayLength(float NewLength, float t0, float T1, bool bShouldTransact);
	bool ScaleCurve(const struct FAnimationCurveIdentifier& CurveId, float Origin, float Factor, bool bShouldTransact);
	bool SetBoneTrackKeys(class FName BoneName, const TArray<struct FVector>& PositionalKeys, const TArray<struct FQuat>& RotationalKeys, const TArray<struct FVector>& ScalingKeys, bool bShouldTransact);
	bool SetCurveColor(const struct FAnimationCurveIdentifier& CurveId, const struct FLinearColor& Color, bool bShouldTransact);
	bool SetCurveFlag(const struct FAnimationCurveIdentifier& CurveId, EAnimAssetCurveFlags Flag, bool bState, bool bShouldTransact);
	bool SetCurveFlags(const struct FAnimationCurveIdentifier& CurveId, int32 Flags_0, bool bShouldTransact);
	bool SetCurveKey(const struct FAnimationCurveIdentifier& CurveId, const struct FRichCurveKey& Key, bool bShouldTransact);
	bool SetCurveKeys(const struct FAnimationCurveIdentifier& CurveId, const TArray<struct FRichCurveKey>& CurveKeys, bool bShouldTransact);
	void SetFrameRate(const struct FFrameRate& FrameRate, bool bShouldTransact);
	void SetModel(TScriptInterface<class IAnimationDataModel> InModel);
	void SetNumberOfFrames(const struct FFrameNumber& NewLengthInFrames, bool bShouldTransact);
	void SetPlayLength(float Length, bool bShouldTransact);
	bool SetTransformCurveKey(const struct FAnimationCurveIdentifier& CurveId, float Time, const struct FTransform& Value, bool bShouldTransact);
	bool SetTransformCurveKeys(const struct FAnimationCurveIdentifier& CurveId, const TArray<struct FTransform>& TransformValues, const TArray<float>& TimeKeys, bool bShouldTransact);
	void UpdateCurveNamesFromSkeleton(const class USkeleton* Skeleton, ERawCurveTrackTypes SupportedCurveType, bool bShouldTransact);

	TScriptInterface<class IAnimationDataModel> GetModelInterface() const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AnimationDataController">();
	}
	static class IAnimationDataController* GetDefaultObj()
	{
		return GetDefaultObjImpl<IAnimationDataController>();
	}

	class UObject* AsUObject()
	{
		return reinterpret_cast<UObject*>(this);
	}
	const class UObject* AsUObject() const
	{
		return reinterpret_cast<const UObject*>(this);
	}
};
static_assert(alignof(IAnimationDataController) == 0x000001, "Wrong alignment on IAnimationDataController");
static_assert(sizeof(IAnimationDataController) == 0x000001, "Wrong size on IAnimationDataController");

// Class Engine.AnimationDataModel
// 0x0000 (0x0000 - 0x0000)
class IAnimationDataModel final
{
public:
	class UAnimSequence* GetAnimationSequence() const;
	const TArray<struct FBoneAnimationTrack> GetBoneAnimationTracks() const;
	const struct FBoneAnimationTrack GetBoneTrackByIndex(int32 TrackIndex) const;
	const struct FBoneAnimationTrack GetBoneTrackByName(class FName TrackName) const;
	int32 GetBoneTrackIndex(const struct FBoneAnimationTrack& Track) const;
	int32 GetBoneTrackIndexByName(class FName TrackName) const;
	void GetBoneTrackNames(TArray<class FName>* OutNames) const;
	struct FFrameRate GetFrameRate() const;
	int32 GetNumberOfFloatCurves() const;
	int32 GetNumberOfFrames() const;
	int32 GetNumberOfKeys() const;
	int32 GetNumberOfTransformCurves() const;
	int32 GetNumBoneTracks() const;
	double GetPlayLength() const;
	bool IsValidBoneTrackIndex(int32 TrackIndex) const;
	bool IsValidBoneTrackName(const class FName& TrackName) const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AnimationDataModel">();
	}
	static class IAnimationDataModel* GetDefaultObj()
	{
		return GetDefaultObjImpl<IAnimationDataModel>();
	}

	class UObject* AsUObject()
	{
		return reinterpret_cast<UObject*>(this);
	}
	const class UObject* AsUObject() const
	{
		return reinterpret_cast<const UObject*>(this);
	}
};
static_assert(alignof(IAnimationDataModel) == 0x000001, "Wrong alignment on IAnimationDataModel");
static_assert(sizeof(IAnimationDataModel) == 0x000001, "Wrong size on IAnimationDataModel");

// Class Engine.MaterialExpressionParticleSize
// 0x0000 (0x00B0 - 0x00B0)
class UMaterialExpressionParticleSize final : public UMaterialExpression
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionParticleSize">();
	}
	static class UMaterialExpressionParticleSize* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionParticleSize>();
	}
};
static_assert(alignof(UMaterialExpressionParticleSize) == 0x000008, "Wrong alignment on UMaterialExpressionParticleSize");
static_assert(sizeof(UMaterialExpressionParticleSize) == 0x0000B0, "Wrong size on UMaterialExpressionParticleSize");

// Class Engine.ParticleModuleCameraBase
// 0x0000 (0x0030 - 0x0030)
class UParticleModuleCameraBase : public UParticleModule
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ParticleModuleCameraBase">();
	}
	static class UParticleModuleCameraBase* GetDefaultObj()
	{
		return GetDefaultObjImpl<UParticleModuleCameraBase>();
	}
};
static_assert(alignof(UParticleModuleCameraBase) == 0x000008, "Wrong alignment on UParticleModuleCameraBase");
static_assert(sizeof(UParticleModuleCameraBase) == 0x000030, "Wrong size on UParticleModuleCameraBase");

// Class Engine.ParticleModuleCameraOffset
// 0x0038 (0x0068 - 0x0030)
class UParticleModuleCameraOffset final : public UParticleModuleCameraBase
{
public:
	struct FRawDistributionFloat                  CameraOffset;                                      // 0x0030(0x0030)(Edit, ContainsInstancedReference, NativeAccessSpecifierPublic)
	uint8                                         bSpawnTimeOnly : 1;                                // 0x0060(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_61[0x3];                                       // 0x0061(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	EParticleCameraOffsetUpdateMethod             UpdateMethod;                                      // 0x0064(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_65[0x3];                                       // 0x0065(0x0003)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ParticleModuleCameraOffset">();
	}
	static class UParticleModuleCameraOffset* GetDefaultObj()
	{
		return GetDefaultObjImpl<UParticleModuleCameraOffset>();
	}
};
static_assert(alignof(UParticleModuleCameraOffset) == 0x000008, "Wrong alignment on UParticleModuleCameraOffset");
static_assert(sizeof(UParticleModuleCameraOffset) == 0x000068, "Wrong size on UParticleModuleCameraOffset");
static_assert(offsetof(UParticleModuleCameraOffset, CameraOffset) == 0x000030, "Member 'UParticleModuleCameraOffset::CameraOffset' has a wrong offset!");
static_assert(offsetof(UParticleModuleCameraOffset, UpdateMethod) == 0x000064, "Member 'UParticleModuleCameraOffset::UpdateMethod' has a wrong offset!");

// Class Engine.InGameAdManager
// 0x0028 (0x0060 - 0x0038)
class UInGameAdManager final : public UPlatformInterfaceBase
{
public:
	uint8                                         bShouldPauseWhileAdOpen : 1;                       // 0x0038(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_39[0x7];                                       // 0x0039(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<TDelegate<void()>>                     ClickedBannerDelegates;                            // 0x0040(0x0010)(ZeroConstructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
	TArray<TDelegate<void()>>                     ClosedAdDelegates;                                 // 0x0050(0x0010)(ZeroConstructor, ContainsInstancedReference, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"InGameAdManager">();
	}
	static class UInGameAdManager* GetDefaultObj()
	{
		return GetDefaultObjImpl<UInGameAdManager>();
	}
};
static_assert(alignof(UInGameAdManager) == 0x000008, "Wrong alignment on UInGameAdManager");
static_assert(sizeof(UInGameAdManager) == 0x000060, "Wrong size on UInGameAdManager");
static_assert(offsetof(UInGameAdManager, ClickedBannerDelegates) == 0x000040, "Member 'UInGameAdManager::ClickedBannerDelegates' has a wrong offset!");
static_assert(offsetof(UInGameAdManager, ClosedAdDelegates) == 0x000050, "Member 'UInGameAdManager::ClosedAdDelegates' has a wrong offset!");

// Class Engine.Controller
// 0x0098 (0x0338 - 0x02A0)
class AController : public AActor
{
public:
	uint8                                         Pad_2A0[0x8];                                      // 0x02A0(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	class APlayerState*                           PlayerState;                                       // 0x02A8(0x0008)(BlueprintVisible, BlueprintReadOnly, Net, ZeroConstructor, RepNotify, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_2B0[0x8];                                      // 0x02B0(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	TMulticastInlineDelegate<void(float Damage, const class UDamageType* DamageType, class AActor* DamagedActor, class AActor* DamageCauser)> OnInstigatedAnyDamage; // 0x02B8(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	TMulticastInlineDelegate<void(class APawn* OldPawn, class APawn* NewPawn)> OnPossessedPawnChanged; // 0x02C8(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	class FName                                   StateName;                                         // 0x02D8(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class APawn*                                  Pawn;                                              // 0x02E0(0x0008)(Net, ZeroConstructor, RepNotify, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_2E8[0x8];                                      // 0x02E8(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	class ACharacter*                             Character;                                         // 0x02F0(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	class USceneComponent*                        TransformComponent;                                // 0x02F8(0x0008)(ExportObject, ZeroConstructor, InstancedReference, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_300[0x18];                                     // 0x0300(0x0018)(Fixing Size After Last Property [ Dumper-7 ])
	struct FRotator                               ControlRotation;                                   // 0x0318(0x0018)(ZeroConstructor, IsPlainOldData, NoDestructor, Protected, NativeAccessSpecifierProtected)
	uint8                                         bAttachToPawn : 1;                                 // 0x0330(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, DisableEditOnInstance, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
	uint8                                         Pad_331[0x7];                                      // 0x0331(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void ClientSetLocation(const struct FVector& NewLocation, const struct FRotator& NewRotation);
	void ClientSetRotation(const struct FRotator& NewRotation, bool bResetCamera);
	void OnRep_Pawn();
	void OnRep_PlayerState();
	void Possess(class APawn* InPawn);
	void ReceiveInstigatedAnyDamage(float Damage, const class UDamageType* DamageType, class AActor* DamagedActor, class AActor* DamageCauser);
	void ReceivePossess(class APawn* PossessedPawn);
	void ReceiveUnPossess(class APawn* UnpossessedPawn);
	void ResetIgnoreInputFlags();
	void ResetIgnoreLookInput();
	void ResetIgnoreMoveInput();
	void SetControlRotation(const struct FRotator& NewRotation);
	void SetIgnoreLookInput(bool bNewLookInput);
	void SetIgnoreMoveInput(bool bNewMoveInput);
	void SetInitialLocationAndRotation(const struct FVector& NewLocation, const struct FRotator& NewRotation);
	void StopMovement();
	void UnPossess();

	struct FRotator GetControlRotation() const;
	struct FRotator GetDesiredRotation() const;
	void GetPlayerViewPoint(struct FVector* Location, struct FRotator* Rotation) const;
	class AActor* GetViewTarget() const;
	bool IsLocalController() const;
	bool IsLocalPlayerController() const;
	bool IsLookInputIgnored() const;
	bool IsMoveInputIgnored() const;
	bool IsPlayerController() const;
	class APawn* K2_GetPawn() const;
	bool LineOfSightTo(const class AActor* Other, const struct FVector& ViewPoint, bool bAlternateChecks) const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"Controller">();
	}
	static class AController* GetDefaultObj()
	{
		return GetDefaultObjImpl<AController>();
	}
};
static_assert(alignof(AController) == 0x000008, "Wrong alignment on AController");
static_assert(sizeof(AController) == 0x000338, "Wrong size on AController");
static_assert(offsetof(AController, PlayerState) == 0x0002A8, "Member 'AController::PlayerState' has a wrong offset!");
static_assert(offsetof(AController, OnInstigatedAnyDamage) == 0x0002B8, "Member 'AController::OnInstigatedAnyDamage' has a wrong offset!");
static_assert(offsetof(AController, OnPossessedPawnChanged) == 0x0002C8, "Member 'AController::OnPossessedPawnChanged' has a wrong offset!");
static_assert(offsetof(AController, StateName) == 0x0002D8, "Member 'AController::StateName' has a wrong offset!");
static_assert(offsetof(AController, Pawn) == 0x0002E0, "Member 'AController::Pawn' has a wrong offset!");
static_assert(offsetof(AController, Character) == 0x0002F0, "Member 'AController::Character' has a wrong offset!");
static_assert(offsetof(AController, TransformComponent) == 0x0002F8, "Member 'AController::TransformComponent' has a wrong offset!");
static_assert(offsetof(AController, ControlRotation) == 0x000318, "Member 'AController::ControlRotation' has a wrong offset!");

// Class Engine.Interface_ActorSubobject
// 0x0000 (0x0000 - 0x0000)
class IInterface_ActorSubobject final
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"Interface_ActorSubobject">();
	}
	static class IInterface_ActorSubobject* GetDefaultObj()
	{
		return GetDefaultObjImpl<IInterface_ActorSubobject>();
	}

	class UObject* AsUObject()
	{
		return reinterpret_cast<UObject*>(this);
	}
	const class UObject* AsUObject() const
	{
		return reinterpret_cast<const UObject*>(this);
	}
};
static_assert(alignof(IInterface_ActorSubobject) == 0x000001, "Wrong alignment on IInterface_ActorSubobject");
static_assert(sizeof(IInterface_ActorSubobject) == 0x000001, "Wrong size on IInterface_ActorSubobject");

// Class Engine.MaterialExpressionSquareRoot
// 0x0028 (0x00D8 - 0x00B0)
class UMaterialExpressionSquareRoot final : public UMaterialExpression
{
public:
	struct FExpressionInput                       Input;                                             // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionSquareRoot">();
	}
	static class UMaterialExpressionSquareRoot* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionSquareRoot>();
	}
};
static_assert(alignof(UMaterialExpressionSquareRoot) == 0x000008, "Wrong alignment on UMaterialExpressionSquareRoot");
static_assert(sizeof(UMaterialExpressionSquareRoot) == 0x0000D8, "Wrong size on UMaterialExpressionSquareRoot");
static_assert(offsetof(UMaterialExpressionSquareRoot, Input) == 0x0000B0, "Member 'UMaterialExpressionSquareRoot::Input' has a wrong offset!");

// Class Engine.ParticleModuleAttractorParticle
// 0x0080 (0x00B0 - 0x0030)
class UParticleModuleAttractorParticle final : public UParticleModuleAttractorBase
{
public:
	class FName                                   EmitterName;                                       // 0x0030(0x0008)(Edit, ExportObject, ZeroConstructor, NoClear, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FRawDistributionFloat                  Range;                                             // 0x0038(0x0030)(Edit, ContainsInstancedReference, NativeAccessSpecifierPublic)
	uint8                                         bStrengthByDistance : 1;                           // 0x0068(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_69[0x7];                                       // 0x0069(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	struct FRawDistributionFloat                  Strength;                                          // 0x0070(0x0030)(Edit, ContainsInstancedReference, NativeAccessSpecifierPublic)
	uint8                                         bAffectBaseVelocity : 1;                           // 0x00A0(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_A1[0x3];                                       // 0x00A1(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	EAttractorParticleSelectionMethod             SelectionMethod;                                   // 0x00A4(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_A5[0x3];                                       // 0x00A5(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	uint8                                         bRenewSource : 1;                                  // 0x00A8(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bInheritSourceVel : 1;                             // 0x00A8(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_A9[0x3];                                       // 0x00A9(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	int32                                         LastSelIndex;                                      // 0x00AC(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ParticleModuleAttractorParticle">();
	}
	static class UParticleModuleAttractorParticle* GetDefaultObj()
	{
		return GetDefaultObjImpl<UParticleModuleAttractorParticle>();
	}
};
static_assert(alignof(UParticleModuleAttractorParticle) == 0x000008, "Wrong alignment on UParticleModuleAttractorParticle");
static_assert(sizeof(UParticleModuleAttractorParticle) == 0x0000B0, "Wrong size on UParticleModuleAttractorParticle");
static_assert(offsetof(UParticleModuleAttractorParticle, EmitterName) == 0x000030, "Member 'UParticleModuleAttractorParticle::EmitterName' has a wrong offset!");
static_assert(offsetof(UParticleModuleAttractorParticle, Range) == 0x000038, "Member 'UParticleModuleAttractorParticle::Range' has a wrong offset!");
static_assert(offsetof(UParticleModuleAttractorParticle, Strength) == 0x000070, "Member 'UParticleModuleAttractorParticle::Strength' has a wrong offset!");
static_assert(offsetof(UParticleModuleAttractorParticle, SelectionMethod) == 0x0000A4, "Member 'UParticleModuleAttractorParticle::SelectionMethod' has a wrong offset!");
static_assert(offsetof(UParticleModuleAttractorParticle, LastSelIndex) == 0x0000AC, "Member 'UParticleModuleAttractorParticle::LastSelIndex' has a wrong offset!");

// Class Engine.MaterialExpressionSetLocal
// 0x0038 (0x00E8 - 0x00B0)
class UMaterialExpressionSetLocal final : public UMaterialExpression
{
public:
	struct FExpressionExecOutput                  Exec;                                              // 0x00B0(0x0008)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       Value;                                             // 0x00B8(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	class FName                                   LocalName;                                         // 0x00E0(0x0008)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionSetLocal">();
	}
	static class UMaterialExpressionSetLocal* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionSetLocal>();
	}
};
static_assert(alignof(UMaterialExpressionSetLocal) == 0x000008, "Wrong alignment on UMaterialExpressionSetLocal");
static_assert(sizeof(UMaterialExpressionSetLocal) == 0x0000E8, "Wrong size on UMaterialExpressionSetLocal");
static_assert(offsetof(UMaterialExpressionSetLocal, Exec) == 0x0000B0, "Member 'UMaterialExpressionSetLocal::Exec' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionSetLocal, Value) == 0x0000B8, "Member 'UMaterialExpressionSetLocal::Value' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionSetLocal, LocalName) == 0x0000E0, "Member 'UMaterialExpressionSetLocal::LocalName' has a wrong offset!");

// Class Engine.Interface_AsyncCompilation
// 0x0000 (0x0000 - 0x0000)
class IInterface_AsyncCompilation final
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"Interface_AsyncCompilation">();
	}
	static class IInterface_AsyncCompilation* GetDefaultObj()
	{
		return GetDefaultObjImpl<IInterface_AsyncCompilation>();
	}

	class UObject* AsUObject()
	{
		return reinterpret_cast<UObject*>(this);
	}
	const class UObject* AsUObject() const
	{
		return reinterpret_cast<const UObject*>(this);
	}
};
static_assert(alignof(IInterface_AsyncCompilation) == 0x000001, "Wrong alignment on IInterface_AsyncCompilation");
static_assert(sizeof(IInterface_AsyncCompilation) == 0x000001, "Wrong size on IInterface_AsyncCompilation");

// Class Engine.SphereComponent
// 0x0010 (0x05A0 - 0x0590)
class USphereComponent : public UShapeComponent
{
public:
	float                                         SphereRadius;                                      // 0x0590(0x0004)(Edit, BlueprintVisible, ExportObject, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_594[0xC];                                      // 0x0594(0x000C)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void SetSphereRadius(float InSphereRadius, bool bUpdateOverlaps);

	float GetScaledSphereRadius() const;
	float GetShapeScale() const;
	float GetUnscaledSphereRadius() const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"SphereComponent">();
	}
	static class USphereComponent* GetDefaultObj()
	{
		return GetDefaultObjImpl<USphereComponent>();
	}
};
static_assert(alignof(USphereComponent) == 0x000010, "Wrong alignment on USphereComponent");
static_assert(sizeof(USphereComponent) == 0x0005A0, "Wrong size on USphereComponent");
static_assert(offsetof(USphereComponent, SphereRadius) == 0x000590, "Member 'USphereComponent::SphereRadius' has a wrong offset!");

// Class Engine.BoneReferenceSkeletonProvider
// 0x0000 (0x0000 - 0x0000)
class IBoneReferenceSkeletonProvider final
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"BoneReferenceSkeletonProvider">();
	}
	static class IBoneReferenceSkeletonProvider* GetDefaultObj()
	{
		return GetDefaultObjImpl<IBoneReferenceSkeletonProvider>();
	}

	class UObject* AsUObject()
	{
		return reinterpret_cast<UObject*>(this);
	}
	const class UObject* AsUObject() const
	{
		return reinterpret_cast<const UObject*>(this);
	}
};
static_assert(alignof(IBoneReferenceSkeletonProvider) == 0x000001, "Wrong alignment on IBoneReferenceSkeletonProvider");
static_assert(sizeof(IBoneReferenceSkeletonProvider) == 0x000001, "Wrong size on IBoneReferenceSkeletonProvider");

// Class Engine.DeprecatedDataLayerInstance
// 0x0018 (0x0060 - 0x0048)
class UDeprecatedDataLayerInstance final : public UDataLayerInstance
{
public:
	class FName                                   Label;                                             // 0x0048(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	class FName                                   DeprecatedDataLayerFName;                          // 0x0050(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	EDataLayerType                                DataLayerType;                                     // 0x0058(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_59[0x3];                                       // 0x0059(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	struct FColor                                 DebugColor;                                        // 0x005C(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"DeprecatedDataLayerInstance">();
	}
	static class UDeprecatedDataLayerInstance* GetDefaultObj()
	{
		return GetDefaultObjImpl<UDeprecatedDataLayerInstance>();
	}
};
static_assert(alignof(UDeprecatedDataLayerInstance) == 0x000008, "Wrong alignment on UDeprecatedDataLayerInstance");
static_assert(sizeof(UDeprecatedDataLayerInstance) == 0x000060, "Wrong size on UDeprecatedDataLayerInstance");
static_assert(offsetof(UDeprecatedDataLayerInstance, Label) == 0x000048, "Member 'UDeprecatedDataLayerInstance::Label' has a wrong offset!");
static_assert(offsetof(UDeprecatedDataLayerInstance, DeprecatedDataLayerFName) == 0x000050, "Member 'UDeprecatedDataLayerInstance::DeprecatedDataLayerFName' has a wrong offset!");
static_assert(offsetof(UDeprecatedDataLayerInstance, DataLayerType) == 0x000058, "Member 'UDeprecatedDataLayerInstance::DataLayerType' has a wrong offset!");
static_assert(offsetof(UDeprecatedDataLayerInstance, DebugColor) == 0x00005C, "Member 'UDeprecatedDataLayerInstance::DebugColor' has a wrong offset!");

// Class Engine.MaterialExpressionHairAttributes
// 0x0008 (0x00B8 - 0x00B0)
class UMaterialExpressionHairAttributes final : public UMaterialExpression
{
public:
	uint8                                         bUseTangentSpace : 1;                              // 0x00B0(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_B1[0x7];                                       // 0x00B1(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionHairAttributes">();
	}
	static class UMaterialExpressionHairAttributes* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionHairAttributes>();
	}
};
static_assert(alignof(UMaterialExpressionHairAttributes) == 0x000008, "Wrong alignment on UMaterialExpressionHairAttributes");
static_assert(sizeof(UMaterialExpressionHairAttributes) == 0x0000B8, "Wrong size on UMaterialExpressionHairAttributes");

// Class Engine.Interface_CollisionDataProvider
// 0x0000 (0x0000 - 0x0000)
class IInterface_CollisionDataProvider final
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"Interface_CollisionDataProvider">();
	}
	static class IInterface_CollisionDataProvider* GetDefaultObj()
	{
		return GetDefaultObjImpl<IInterface_CollisionDataProvider>();
	}

	class UObject* AsUObject()
	{
		return reinterpret_cast<UObject*>(this);
	}
	const class UObject* AsUObject() const
	{
		return reinterpret_cast<const UObject*>(this);
	}
};
static_assert(alignof(IInterface_CollisionDataProvider) == 0x000001, "Wrong alignment on IInterface_CollisionDataProvider");
static_assert(sizeof(IInterface_CollisionDataProvider) == 0x000001, "Wrong size on IInterface_CollisionDataProvider");

// Class Engine.PawnMovementComponent
// 0x0008 (0x0160 - 0x0158)
class UPawnMovementComponent : public UNavMovementComponent
{
public:
	class APawn*                                  PawnOwner;                                         // 0x0158(0x0008)(ZeroConstructor, Transient, DuplicateTransient, NoDestructor, Protected, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierProtected)

public:
	void AddInputVector(const struct FVector& WorldVector, bool bForce);
	struct FVector ConsumeInputVector();
	void MulticastAsyncPhysicsStateAction(const class UPrimitiveComponent* ActionComponent, const class FName BoneName, const struct FAsyncPhysicsTimestamp& Timestamp, const EPhysicsStateAction ActionType, const struct FVector& ActionDatas, const struct FVector& ActionPosition);
	void ServerAsyncPhysicsStateAction(const class UPrimitiveComponent* ActionComponent, const class FName BoneName, const struct FAsyncPhysicsTimestamp& Timestamp, const EPhysicsStateAction ActionType, const struct FVector& ActionDatas, const struct FVector& ActionPosition);

	struct FVector GetLastInputVector() const;
	class APawn* GetPawnOwner() const;
	struct FVector GetPendingInputVector() const;
	bool IsMoveInputIgnored() const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"PawnMovementComponent">();
	}
	static class UPawnMovementComponent* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPawnMovementComponent>();
	}
};
static_assert(alignof(UPawnMovementComponent) == 0x000008, "Wrong alignment on UPawnMovementComponent");
static_assert(sizeof(UPawnMovementComponent) == 0x000160, "Wrong size on UPawnMovementComponent");
static_assert(offsetof(UPawnMovementComponent, PawnOwner) == 0x000158, "Member 'UPawnMovementComponent::PawnOwner' has a wrong offset!");

// Class Engine.CharacterMovementComponent
// 0x0E10 (0x0F70 - 0x0160)
#pragma pack(push, 0x1)
class alignas(0x10) UCharacterMovementComponent : public UPawnMovementComponent
{
public:
	uint8                                         Pad_160[0x10];                                     // 0x0160(0x0010)(Fixing Size After Last Property [ Dumper-7 ])
	class ACharacter*                             CharacterOwner;                                    // 0x0170(0x0008)(ZeroConstructor, Transient, DuplicateTransient, NoDestructor, Protected, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	float                                         GravityScale;                                      // 0x0178(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         MaxStepHeight;                                     // 0x017C(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         JumpZVelocity;                                     // 0x0180(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         JumpOffJumpZFactor;                                // 0x0184(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_188[0x1C];                                     // 0x0188(0x001C)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         WalkableFloorAngle;                                // 0x01A4(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	float                                         WalkableFloorZ;                                    // 0x01A8(0x0004)(Edit, ZeroConstructor, EditConst, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_1AC[0x4];                                      // 0x01AC(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	struct FVector                                GravityDirection;                                  // 0x01B0(0x0018)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, EditConst, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_1C8[0x8];                                      // 0x01C8(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	struct FQuat                                  WorldToGravityTransform;                           // 0x01D0(0x0020)(Edit, BlueprintVisible, BlueprintReadOnly, EditConst, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	struct FQuat                                  GravityToWorldTransform;                           // 0x01F0(0x0020)(Edit, BlueprintVisible, BlueprintReadOnly, EditConst, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_210[0x1];                                      // 0x0210(0x0001)(Fixing Size After Last Property [ Dumper-7 ])
	EMovementMode                                 MovementMode;                                      // 0x0211(0x0001)(BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         CustomMovementMode;                                // 0x0212(0x0001)(BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	ENetworkSmoothingMode                         NetworkSmoothingMode;                              // 0x0213(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         GroundFriction;                                    // 0x0214(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_218[0x40];                                     // 0x0218(0x0040)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         MaxWalkSpeed;                                      // 0x0258(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         MaxWalkSpeedCrouched;                              // 0x025C(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         MaxSwimSpeed;                                      // 0x0260(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         MaxFlySpeed;                                       // 0x0264(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         MaxCustomMovementSpeed;                            // 0x0268(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         MaxAcceleration;                                   // 0x026C(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         MinAnalogWalkSpeed;                                // 0x0270(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         BrakingFrictionFactor;                             // 0x0274(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         BrakingFriction;                                   // 0x0278(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         BrakingSubStepTime;                                // 0x027C(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         BrakingDecelerationWalking;                        // 0x0280(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         BrakingDecelerationFalling;                        // 0x0284(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         BrakingDecelerationSwimming;                       // 0x0288(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         BrakingDecelerationFlying;                         // 0x028C(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         AirControl;                                        // 0x0290(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         AirControlBoostMultiplier;                         // 0x0294(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         AirControlBoostVelocityThreshold;                  // 0x0298(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         FallingLateralFriction;                            // 0x029C(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         CrouchedHalfHeight;                                // 0x02A0(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         Buoyancy;                                          // 0x02A4(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         PerchRadiusThreshold;                              // 0x02A8(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         PerchAdditionalHeight;                             // 0x02AC(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FRotator                               RotationRate;                                      // 0x02B0(0x0018)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
	uint8                                         bUseSeparateBrakingFriction : 1;                   // 0x02C8(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, BlueprintVisible, DisableEditOnInstance, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bApplyGravityWhileJumping : 1;                     // 0x02C8(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bUseControllerDesiredRotation : 1;                 // 0x02C8(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bOrientRotationToMovement : 1;                     // 0x02C8(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bSweepWhileNavWalking : 1;                         // 0x02C8(0x0001)(BitIndex: 0x04, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         BitPad_2C8_5 : 1;                                  // 0x02C8(0x0001)(Fixing Bit-Field Size Between Bits [ Dumper-7 ])
	uint8                                         bMovementInProgress : 1;                           // 0x02C8(0x0001)(BitIndex: 0x06, PropSize: 0x0001 (NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
	uint8                                         bEnableScopedMovementUpdates : 1;                  // 0x02C8(0x0001)(BitIndex: 0x07, PropSize: 0x0001 (Edit, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bEnableServerDualMoveScopedMovementUpdates : 1;    // 0x02C9(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bForceMaxAccel : 1;                                // 0x02C9(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bRunPhysicsWithNoController : 1;                   // 0x02C9(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bForceNextFloorCheck : 1;                          // 0x02C9(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (Edit, BlueprintVisible, DisableEditOnTemplate, EditConst, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bShrinkProxyCapsule : 1;                           // 0x02C9(0x0001)(BitIndex: 0x04, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bCanWalkOffLedges : 1;                             // 0x02C9(0x0001)(BitIndex: 0x05, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bCanWalkOffLedgesWhenCrouching : 1;                // 0x02C9(0x0001)(BitIndex: 0x06, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         BitPad_2C9_7 : 1;                                  // 0x02C9(0x0001)(Fixing Bit-Field Size For New Byte [ Dumper-7 ])
	uint8                                         BitPad_2CA_0 : 1;                                  // 0x02CA(0x0001)(Fixing Bit-Field Size Between Bits [ Dumper-7 ])
	uint8                                         bNetworkSkipProxyPredictionOnNetUpdate : 1;        // 0x02CA(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, DisableEditOnInstance, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bNetworkAlwaysReplicateTransformUpdateTimestamp : 1; // 0x02CA(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Edit, DisableEditOnInstance, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bDeferUpdateMoveComponent : 1;                     // 0x02CA(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bEnablePhysicsInteraction : 1;                     // 0x02CA(0x0001)(BitIndex: 0x04, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bTouchForceScaledToMass : 1;                       // 0x02CA(0x0001)(BitIndex: 0x05, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bPushForceScaledToMass : 1;                        // 0x02CA(0x0001)(BitIndex: 0x06, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bPushForceUsingZOffset : 1;                        // 0x02CA(0x0001)(BitIndex: 0x07, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bScalePushForceToVelocity : 1;                     // 0x02CB(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_2CC[0x4];                                      // 0x02CC(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	class USceneComponent*                        DeferredUpdatedMoveComponent;                      // 0x02D0(0x0008)(ExportObject, ZeroConstructor, InstancedReference, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         MaxOutOfWaterStepHeight;                           // 0x02D8(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         OutofWaterZ;                                       // 0x02DC(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         Mass;                                              // 0x02E0(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         StandingDownwardForceScale;                        // 0x02E4(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         InitialPushForceFactor;                            // 0x02E8(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         PushForceFactor;                                   // 0x02EC(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         PushForcePointZOffsetFactor;                       // 0x02F0(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         TouchForceFactor;                                  // 0x02F4(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         MinTouchForce;                                     // 0x02F8(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         MaxTouchForce;                                     // 0x02FC(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         RepulsionForce;                                    // 0x0300(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_304[0x4];                                      // 0x0304(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	struct FVector                                Acceleration;                                      // 0x0308(0x0018)(ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	struct FQuat                                  LastUpdateRotation;                                // 0x0320(0x0020)(IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	struct FVector                                LastUpdateLocation;                                // 0x0340(0x0018)(ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	struct FVector                                LastUpdateVelocity;                                // 0x0358(0x0018)(ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	float                                         ServerLastTransformUpdateTimeStamp;                // 0x0370(0x0004)(ZeroConstructor, Transient, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	float                                         ServerLastClientGoodMoveAckTime;                   // 0x0374(0x0004)(ZeroConstructor, Transient, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	float                                         ServerLastClientAdjustmentTime;                    // 0x0378(0x0004)(ZeroConstructor, Transient, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_37C[0x4];                                      // 0x037C(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	struct FVector                                PendingImpulseToApply;                             // 0x0380(0x0018)(ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	struct FVector                                PendingForceToApply;                               // 0x0398(0x0018)(ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	float                                         AnalogInputModifier;                               // 0x03B0(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_3B4[0xC];                                      // 0x03B4(0x000C)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         MaxSimulationTimeStep;                             // 0x03C0(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         MaxSimulationIterations;                           // 0x03C4(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         MaxJumpApexAttemptsPerSimulation;                  // 0x03C8(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         MaxDepenetrationWithGeometry;                      // 0x03CC(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         MaxDepenetrationWithGeometryAsProxy;               // 0x03D0(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         MaxDepenetrationWithPawn;                          // 0x03D4(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         MaxDepenetrationWithPawnAsProxy;                   // 0x03D8(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         NetworkSimulatedSmoothLocationTime;                // 0x03DC(0x0004)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         NetworkSimulatedSmoothRotationTime;                // 0x03E0(0x0004)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         ListenServerNetworkSimulatedSmoothLocationTime;    // 0x03E4(0x0004)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         ListenServerNetworkSimulatedSmoothRotationTime;    // 0x03E8(0x0004)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         NetProxyShrinkRadius;                              // 0x03EC(0x0004)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         NetProxyShrinkHalfHeight;                          // 0x03F0(0x0004)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         NetworkMaxSmoothUpdateDistance;                    // 0x03F4(0x0004)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         NetworkNoSmoothUpdateDistance;                     // 0x03F8(0x0004)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         NetworkMinTimeBetweenClientAckGoodMoves;           // 0x03FC(0x0004)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         NetworkMinTimeBetweenClientAdjustments;            // 0x0400(0x0004)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         NetworkMinTimeBetweenClientAdjustmentsLargeCorrection; // 0x0404(0x0004)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         NetworkLargeClientCorrectionDistance;              // 0x0408(0x0004)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         LedgeCheckThreshold;                               // 0x040C(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         JumpOutOfWaterPitch;                               // 0x0410(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_414[0x4];                                      // 0x0414(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	struct FFindFloorResult                       CurrentFloor;                                      // 0x0418(0x00F8)(Edit, BlueprintVisible, BlueprintReadOnly, DisableEditOnTemplate, EditConst, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
	EMovementMode                                 DefaultLandMovementMode;                           // 0x0510(0x0001)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EMovementMode                                 DefaultWaterMovementMode;                          // 0x0511(0x0001)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EMovementMode                                 GroundMovementMode;                                // 0x0512(0x0001)(ZeroConstructor, Transient, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_513[0x9];                                      // 0x0513(0x0009)(Fixing Size After Last Property [ Dumper-7 ])
	uint8                                         bMaintainHorizontalGroundVelocity : 1;             // 0x051C(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bImpartBaseVelocityX : 1;                          // 0x051C(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bImpartBaseVelocityY : 1;                          // 0x051C(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bImpartBaseVelocityZ : 1;                          // 0x051C(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bImpartBaseAngularVelocity : 1;                    // 0x051C(0x0001)(BitIndex: 0x04, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bJustTeleported : 1;                               // 0x051C(0x0001)(BitIndex: 0x05, PropSize: 0x0001 (Edit, BlueprintVisible, DisableEditOnTemplate, Transient, EditConst, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bNetworkUpdateReceived : 1;                        // 0x051C(0x0001)(BitIndex: 0x06, PropSize: 0x0001 (Transient, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bNetworkMovementModeChanged : 1;                   // 0x051C(0x0001)(BitIndex: 0x07, PropSize: 0x0001 (Transient, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bNetworkGravityDirectionChanged : 1;               // 0x051D(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Transient, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bIgnoreClientMovementErrorChecksAndCorrection : 1; // 0x051D(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, BlueprintVisible, Transient, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bServerAcceptClientAuthoritativePosition : 1;      // 0x051D(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Edit, BlueprintVisible, Transient, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bNotifyApex : 1;                                   // 0x051D(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (Edit, BlueprintVisible, EditConst, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bCheatFlying : 1;                                  // 0x051D(0x0001)(BitIndex: 0x04, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bWantsToCrouch : 1;                                // 0x051D(0x0001)(BitIndex: 0x05, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, DisableEditOnTemplate, EditConst, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bCrouchMaintainsBaseLocation : 1;                  // 0x051D(0x0001)(BitIndex: 0x06, PropSize: 0x0001 (Edit, BlueprintVisible, DisableEditOnTemplate, EditConst, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bIgnoreBaseRotation : 1;                           // 0x051D(0x0001)(BitIndex: 0x07, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bFastAttachedMove : 1;                             // 0x051E(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bAlwaysCheckFloor : 1;                             // 0x051E(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bUseFlatBaseForFloorChecks : 1;                    // 0x051E(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bPerformingJumpOff : 1;                            // 0x051E(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bWantsToLeaveNavWalking : 1;                       // 0x051E(0x0001)(BitIndex: 0x04, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bUseRVOAvoidance : 1;                              // 0x051E(0x0001)(BitIndex: 0x05, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bRequestedMoveUseAcceleration : 1;                 // 0x051E(0x0001)(BitIndex: 0x06, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         BitPad_51E_7 : 1;                                  // 0x051E(0x0001)(Fixing Bit-Field Size For New Byte [ Dumper-7 ])
	uint8                                         bWasSimulatingRootMotion : 1;                      // 0x051F(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Transient, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bAllowPhysicsRotationDuringAnimRootMotion : 1;     // 0x051F(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	float                                         FormerBaseVelocityDecayHalfLife;                   // 0x0520(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bHasRequestedVelocity : 1;                         // 0x0524(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Transient, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
	uint8                                         bRequestedMoveWithMaxSpeed : 1;                    // 0x0524(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Transient, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
	uint8                                         bWasAvoidanceUpdated : 1;                          // 0x0524(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Transient, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
	uint8                                         BitPad_524_3 : 2;                                  // 0x0524(0x0001)(Fixing Bit-Field Size Between Bits [ Dumper-7 ])
	uint8                                         bProjectNavMeshWalking : 1;                        // 0x0524(0x0001)(BitIndex: 0x05, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
	uint8                                         bProjectNavMeshOnBothWorldChannels : 1;            // 0x0524(0x0001)(BitIndex: 0x06, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, AdvancedDisplay, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
	uint8                                         Pad_525[0x1F];                                     // 0x0525(0x001F)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         AvoidanceConsiderationRadius;                      // 0x0544(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector                                RequestedVelocity;                                 // 0x0548(0x0018)(ZeroConstructor, Transient, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector                                LastUpdateRequestedVelocity;                       // 0x0560(0x0018)(ZeroConstructor, Transient, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         AvoidanceUID;                                      // 0x0578(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, EditConst, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FNavAvoidanceMask                      AvoidanceGroup;                                    // 0x057C(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, AdvancedDisplay, NativeAccessSpecifierPublic)
	struct FNavAvoidanceMask                      GroupsToAvoid;                                     // 0x0580(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, AdvancedDisplay, NativeAccessSpecifierPublic)
	struct FNavAvoidanceMask                      GroupsToIgnore;                                    // 0x0584(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, AdvancedDisplay, NativeAccessSpecifierPublic)
	float                                         AvoidanceWeight;                                   // 0x0588(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_58C[0x4];                                      // 0x058C(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	struct FVector                                PendingLaunchVelocity;                             // 0x0590(0x0018)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_5A8[0x138];                                    // 0x05A8(0x0138)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         NavMeshProjectionInterval;                         // 0x06E0(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         NavMeshProjectionTimer;                            // 0x06E4(0x0004)(ZeroConstructor, Transient, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         NavMeshProjectionInterpSpeed;                      // 0x06E8(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         NavMeshProjectionHeightScaleUp;                    // 0x06EC(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         NavMeshProjectionHeightScaleDown;                  // 0x06F0(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         NavWalkingFloorDistTolerance;                      // 0x06F4(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_6F8[0x38];                                     // 0x06F8(0x0038)(Fixing Size After Last Property [ Dumper-7 ])
	struct FCharacterMovementComponentPostPhysicsTickFunction PostPhysicsTickFunction;               // 0x0730(0x0038)(NativeAccessSpecifierPublic)
	uint8                                         Pad_768[0x18];                                     // 0x0768(0x0018)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         MinTimeBetweenTimeStampResets;                     // 0x0780(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_784[0x54C];                                    // 0x0784(0x054C)(Fixing Size After Last Property [ Dumper-7 ])
	struct FRootMotionSourceGroup                 CurrentRootMotion;                                 // 0x0CD0(0x0048)(Transient, NativeAccessSpecifierPublic)
	struct FRootMotionSourceGroup                 ServerCorrectionRootMotion;                        // 0x0D18(0x0048)(Transient, NativeAccessSpecifierPublic)
	uint8                                         Pad_D60[0x160];                                    // 0x0D60(0x0160)(Fixing Size After Last Property [ Dumper-7 ])
	struct FRootMotionMovementParams              RootMotionParams;                                  // 0x0EC0(0x0070)(Transient, NoDestructor, NativeAccessSpecifierPublic)
	struct FVector                                AnimRootMotionVelocity;                            // 0x0F30(0x0018)(ZeroConstructor, Transient, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_F48[0x20];                                     // 0x0F48(0x0020)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void AddForce(const struct FVector& Force);
	void AddImpulse(const struct FVector& Impulse, bool bVelocityChange);
	void CalcVelocity(float DeltaTime, float Friction, bool bFluid, float BrakingDeceleration);
	void CapsuleTouched(class UPrimitiveComponent* OverlappedComp, class AActor* Other, class UPrimitiveComponent* OtherComp, int32 OtherBodyIndex, bool bFromSweep, const struct FHitResult& SweepResult);
	void ClearAccumulatedForces();
	void DisableMovement();
	void SetAvoidanceEnabled(bool bEnable);
	void SetAvoidanceGroup(int32 GroupFlags);
	void SetAvoidanceGroupMask(const struct FNavAvoidanceMask& GroupMask);
	void SetCrouchedHalfHeight(const float NewValue);
	void SetGroupsToAvoid(int32 GroupFlags);
	void SetGroupsToAvoidMask(const struct FNavAvoidanceMask& GroupMask);
	void SetGroupsToIgnore(int32 GroupFlags);
	void SetGroupsToIgnoreMask(const struct FNavAvoidanceMask& GroupMask);
	void SetMovementMode(EMovementMode NewMovementMode, uint8 NewCustomMode);
	void SetWalkableFloorAngle(float InWalkableFloorAngle);
	void SetWalkableFloorZ(float InWalkableFloorZ);

	float GetAnalogInputModifier() const;
	class ACharacter* GetCharacterOwner() const;
	float GetCrouchedHalfHeight() const;
	struct FVector GetCurrentAcceleration() const;
	struct FVector GetImpartedMovementBaseVelocity() const;
	struct FVector GetLastUpdateLocation() const;
	struct FVector GetLastUpdateRequestedVelocity() const;
	struct FRotator GetLastUpdateRotation() const;
	struct FVector GetLastUpdateVelocity() const;
	float GetMaxAcceleration() const;
	float GetMaxBrakingDeceleration() const;
	float GetMaxJumpHeight() const;
	float GetMaxJumpHeightWithJumpTime() const;
	float GetMinAnalogSpeed() const;
	class UPrimitiveComponent* GetMovementBase() const;
	float GetPerchRadiusThreshold() const;
	float GetValidPerchRadius() const;
	bool IsWalkable(const struct FHitResult& Hit) const;
	bool IsWalking() const;
	void K2_ComputeFloorDist(const struct FVector& CapsuleLocation, float LineDistance, float SweepDistance, float SweepRadius, struct FFindFloorResult* FloorResult) const;
	void K2_FindFloor(const struct FVector& CapsuleLocation, struct FFindFloorResult* FloorResult) const;
	float K2_GetWalkableFloorAngle() const;
	float K2_GetWalkableFloorZ() const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"CharacterMovementComponent">();
	}
	static class UCharacterMovementComponent* GetDefaultObj()
	{
		return GetDefaultObjImpl<UCharacterMovementComponent>();
	}
};
#pragma pack(pop)
static_assert(alignof(UCharacterMovementComponent) == 0x000010, "Wrong alignment on UCharacterMovementComponent");
static_assert(sizeof(UCharacterMovementComponent) == 0x000F70, "Wrong size on UCharacterMovementComponent");
static_assert(offsetof(UCharacterMovementComponent, CharacterOwner) == 0x000170, "Member 'UCharacterMovementComponent::CharacterOwner' has a wrong offset!");
static_assert(offsetof(UCharacterMovementComponent, GravityScale) == 0x000178, "Member 'UCharacterMovementComponent::GravityScale' has a wrong offset!");
static_assert(offsetof(UCharacterMovementComponent, MaxStepHeight) == 0x00017C, "Member 'UCharacterMovementComponent::MaxStepHeight' has a wrong offset!");
static_assert(offsetof(UCharacterMovementComponent, JumpZVelocity) == 0x000180, "Member 'UCharacterMovementComponent::JumpZVelocity' has a wrong offset!");
static_assert(offsetof(UCharacterMovementComponent, JumpOffJumpZFactor) == 0x000184, "Member 'UCharacterMovementComponent::JumpOffJumpZFactor' has a wrong offset!");
static_assert(offsetof(UCharacterMovementComponent, WalkableFloorAngle) == 0x0001A4, "Member 'UCharacterMovementComponent::WalkableFloorAngle' has a wrong offset!");
static_assert(offsetof(UCharacterMovementComponent, WalkableFloorZ) == 0x0001A8, "Member 'UCharacterMovementComponent::WalkableFloorZ' has a wrong offset!");
static_assert(offsetof(UCharacterMovementComponent, GravityDirection) == 0x0001B0, "Member 'UCharacterMovementComponent::GravityDirection' has a wrong offset!");
static_assert(offsetof(UCharacterMovementComponent, WorldToGravityTransform) == 0x0001D0, "Member 'UCharacterMovementComponent::WorldToGravityTransform' has a wrong offset!");
static_assert(offsetof(UCharacterMovementComponent, GravityToWorldTransform) == 0x0001F0, "Member 'UCharacterMovementComponent::GravityToWorldTransform' has a wrong offset!");
static_assert(offsetof(UCharacterMovementComponent, MovementMode) == 0x000211, "Member 'UCharacterMovementComponent::MovementMode' has a wrong offset!");
static_assert(offsetof(UCharacterMovementComponent, CustomMovementMode) == 0x000212, "Member 'UCharacterMovementComponent::CustomMovementMode' has a wrong offset!");
static_assert(offsetof(UCharacterMovementComponent, NetworkSmoothingMode) == 0x000213, "Member 'UCharacterMovementComponent::NetworkSmoothingMode' has a wrong offset!");
static_assert(offsetof(UCharacterMovementComponent, GroundFriction) == 0x000214, "Member 'UCharacterMovementComponent::GroundFriction' has a wrong offset!");
static_assert(offsetof(UCharacterMovementComponent, MaxWalkSpeed) == 0x000258, "Member 'UCharacterMovementComponent::MaxWalkSpeed' has a wrong offset!");
static_assert(offsetof(UCharacterMovementComponent, MaxWalkSpeedCrouched) == 0x00025C, "Member 'UCharacterMovementComponent::MaxWalkSpeedCrouched' has a wrong offset!");
static_assert(offsetof(UCharacterMovementComponent, MaxSwimSpeed) == 0x000260, "Member 'UCharacterMovementComponent::MaxSwimSpeed' has a wrong offset!");
static_assert(offsetof(UCharacterMovementComponent, MaxFlySpeed) == 0x000264, "Member 'UCharacterMovementComponent::MaxFlySpeed' has a wrong offset!");
static_assert(offsetof(UCharacterMovementComponent, MaxCustomMovementSpeed) == 0x000268, "Member 'UCharacterMovementComponent::MaxCustomMovementSpeed' has a wrong offset!");
static_assert(offsetof(UCharacterMovementComponent, MaxAcceleration) == 0x00026C, "Member 'UCharacterMovementComponent::MaxAcceleration' has a wrong offset!");
static_assert(offsetof(UCharacterMovementComponent, MinAnalogWalkSpeed) == 0x000270, "Member 'UCharacterMovementComponent::MinAnalogWalkSpeed' has a wrong offset!");
static_assert(offsetof(UCharacterMovementComponent, BrakingFrictionFactor) == 0x000274, "Member 'UCharacterMovementComponent::BrakingFrictionFactor' has a wrong offset!");
static_assert(offsetof(UCharacterMovementComponent, BrakingFriction) == 0x000278, "Member 'UCharacterMovementComponent::BrakingFriction' has a wrong offset!");
static_assert(offsetof(UCharacterMovementComponent, BrakingSubStepTime) == 0x00027C, "Member 'UCharacterMovementComponent::BrakingSubStepTime' has a wrong offset!");
static_assert(offsetof(UCharacterMovementComponent, BrakingDecelerationWalking) == 0x000280, "Member 'UCharacterMovementComponent::BrakingDecelerationWalking' has a wrong offset!");
static_assert(offsetof(UCharacterMovementComponent, BrakingDecelerationFalling) == 0x000284, "Member 'UCharacterMovementComponent::BrakingDecelerationFalling' has a wrong offset!");
static_assert(offsetof(UCharacterMovementComponent, BrakingDecelerationSwimming) == 0x000288, "Member 'UCharacterMovementComponent::BrakingDecelerationSwimming' has a wrong offset!");
static_assert(offsetof(UCharacterMovementComponent, BrakingDecelerationFlying) == 0x00028C, "Member 'UCharacterMovementComponent::BrakingDecelerationFlying' has a wrong offset!");
static_assert(offsetof(UCharacterMovementComponent, AirControl) == 0x000290, "Member 'UCharacterMovementComponent::AirControl' has a wrong offset!");
static_assert(offsetof(UCharacterMovementComponent, AirControlBoostMultiplier) == 0x000294, "Member 'UCharacterMovementComponent::AirControlBoostMultiplier' has a wrong offset!");
static_assert(offsetof(UCharacterMovementComponent, AirControlBoostVelocityThreshold) == 0x000298, "Member 'UCharacterMovementComponent::AirControlBoostVelocityThreshold' has a wrong offset!");
static_assert(offsetof(UCharacterMovementComponent, FallingLateralFriction) == 0x00029C, "Member 'UCharacterMovementComponent::FallingLateralFriction' has a wrong offset!");
static_assert(offsetof(UCharacterMovementComponent, CrouchedHalfHeight) == 0x0002A0, "Member 'UCharacterMovementComponent::CrouchedHalfHeight' has a wrong offset!");
static_assert(offsetof(UCharacterMovementComponent, Buoyancy) == 0x0002A4, "Member 'UCharacterMovementComponent::Buoyancy' has a wrong offset!");
static_assert(offsetof(UCharacterMovementComponent, PerchRadiusThreshold) == 0x0002A8, "Member 'UCharacterMovementComponent::PerchRadiusThreshold' has a wrong offset!");
static_assert(offsetof(UCharacterMovementComponent, PerchAdditionalHeight) == 0x0002AC, "Member 'UCharacterMovementComponent::PerchAdditionalHeight' has a wrong offset!");
static_assert(offsetof(UCharacterMovementComponent, RotationRate) == 0x0002B0, "Member 'UCharacterMovementComponent::RotationRate' has a wrong offset!");
static_assert(offsetof(UCharacterMovementComponent, DeferredUpdatedMoveComponent) == 0x0002D0, "Member 'UCharacterMovementComponent::DeferredUpdatedMoveComponent' has a wrong offset!");
static_assert(offsetof(UCharacterMovementComponent, MaxOutOfWaterStepHeight) == 0x0002D8, "Member 'UCharacterMovementComponent::MaxOutOfWaterStepHeight' has a wrong offset!");
static_assert(offsetof(UCharacterMovementComponent, OutofWaterZ) == 0x0002DC, "Member 'UCharacterMovementComponent::OutofWaterZ' has a wrong offset!");
static_assert(offsetof(UCharacterMovementComponent, Mass) == 0x0002E0, "Member 'UCharacterMovementComponent::Mass' has a wrong offset!");
static_assert(offsetof(UCharacterMovementComponent, StandingDownwardForceScale) == 0x0002E4, "Member 'UCharacterMovementComponent::StandingDownwardForceScale' has a wrong offset!");
static_assert(offsetof(UCharacterMovementComponent, InitialPushForceFactor) == 0x0002E8, "Member 'UCharacterMovementComponent::InitialPushForceFactor' has a wrong offset!");
static_assert(offsetof(UCharacterMovementComponent, PushForceFactor) == 0x0002EC, "Member 'UCharacterMovementComponent::PushForceFactor' has a wrong offset!");
static_assert(offsetof(UCharacterMovementComponent, PushForcePointZOffsetFactor) == 0x0002F0, "Member 'UCharacterMovementComponent::PushForcePointZOffsetFactor' has a wrong offset!");
static_assert(offsetof(UCharacterMovementComponent, TouchForceFactor) == 0x0002F4, "Member 'UCharacterMovementComponent::TouchForceFactor' has a wrong offset!");
static_assert(offsetof(UCharacterMovementComponent, MinTouchForce) == 0x0002F8, "Member 'UCharacterMovementComponent::MinTouchForce' has a wrong offset!");
static_assert(offsetof(UCharacterMovementComponent, MaxTouchForce) == 0x0002FC, "Member 'UCharacterMovementComponent::MaxTouchForce' has a wrong offset!");
static_assert(offsetof(UCharacterMovementComponent, RepulsionForce) == 0x000300, "Member 'UCharacterMovementComponent::RepulsionForce' has a wrong offset!");
static_assert(offsetof(UCharacterMovementComponent, Acceleration) == 0x000308, "Member 'UCharacterMovementComponent::Acceleration' has a wrong offset!");
static_assert(offsetof(UCharacterMovementComponent, LastUpdateRotation) == 0x000320, "Member 'UCharacterMovementComponent::LastUpdateRotation' has a wrong offset!");
static_assert(offsetof(UCharacterMovementComponent, LastUpdateLocation) == 0x000340, "Member 'UCharacterMovementComponent::LastUpdateLocation' has a wrong offset!");
static_assert(offsetof(UCharacterMovementComponent, LastUpdateVelocity) == 0x000358, "Member 'UCharacterMovementComponent::LastUpdateVelocity' has a wrong offset!");
static_assert(offsetof(UCharacterMovementComponent, ServerLastTransformUpdateTimeStamp) == 0x000370, "Member 'UCharacterMovementComponent::ServerLastTransformUpdateTimeStamp' has a wrong offset!");
static_assert(offsetof(UCharacterMovementComponent, ServerLastClientGoodMoveAckTime) == 0x000374, "Member 'UCharacterMovementComponent::ServerLastClientGoodMoveAckTime' has a wrong offset!");
static_assert(offsetof(UCharacterMovementComponent, ServerLastClientAdjustmentTime) == 0x000378, "Member 'UCharacterMovementComponent::ServerLastClientAdjustmentTime' has a wrong offset!");
static_assert(offsetof(UCharacterMovementComponent, PendingImpulseToApply) == 0x000380, "Member 'UCharacterMovementComponent::PendingImpulseToApply' has a wrong offset!");
static_assert(offsetof(UCharacterMovementComponent, PendingForceToApply) == 0x000398, "Member 'UCharacterMovementComponent::PendingForceToApply' has a wrong offset!");
static_assert(offsetof(UCharacterMovementComponent, AnalogInputModifier) == 0x0003B0, "Member 'UCharacterMovementComponent::AnalogInputModifier' has a wrong offset!");
static_assert(offsetof(UCharacterMovementComponent, MaxSimulationTimeStep) == 0x0003C0, "Member 'UCharacterMovementComponent::MaxSimulationTimeStep' has a wrong offset!");
static_assert(offsetof(UCharacterMovementComponent, MaxSimulationIterations) == 0x0003C4, "Member 'UCharacterMovementComponent::MaxSimulationIterations' has a wrong offset!");
static_assert(offsetof(UCharacterMovementComponent, MaxJumpApexAttemptsPerSimulation) == 0x0003C8, "Member 'UCharacterMovementComponent::MaxJumpApexAttemptsPerSimulation' has a wrong offset!");
static_assert(offsetof(UCharacterMovementComponent, MaxDepenetrationWithGeometry) == 0x0003CC, "Member 'UCharacterMovementComponent::MaxDepenetrationWithGeometry' has a wrong offset!");
static_assert(offsetof(UCharacterMovementComponent, MaxDepenetrationWithGeometryAsProxy) == 0x0003D0, "Member 'UCharacterMovementComponent::MaxDepenetrationWithGeometryAsProxy' has a wrong offset!");
static_assert(offsetof(UCharacterMovementComponent, MaxDepenetrationWithPawn) == 0x0003D4, "Member 'UCharacterMovementComponent::MaxDepenetrationWithPawn' has a wrong offset!");
static_assert(offsetof(UCharacterMovementComponent, MaxDepenetrationWithPawnAsProxy) == 0x0003D8, "Member 'UCharacterMovementComponent::MaxDepenetrationWithPawnAsProxy' has a wrong offset!");
static_assert(offsetof(UCharacterMovementComponent, NetworkSimulatedSmoothLocationTime) == 0x0003DC, "Member 'UCharacterMovementComponent::NetworkSimulatedSmoothLocationTime' has a wrong offset!");
static_assert(offsetof(UCharacterMovementComponent, NetworkSimulatedSmoothRotationTime) == 0x0003E0, "Member 'UCharacterMovementComponent::NetworkSimulatedSmoothRotationTime' has a wrong offset!");
static_assert(offsetof(UCharacterMovementComponent, ListenServerNetworkSimulatedSmoothLocationTime) == 0x0003E4, "Member 'UCharacterMovementComponent::ListenServerNetworkSimulatedSmoothLocationTime' has a wrong offset!");
static_assert(offsetof(UCharacterMovementComponent, ListenServerNetworkSimulatedSmoothRotationTime) == 0x0003E8, "Member 'UCharacterMovementComponent::ListenServerNetworkSimulatedSmoothRotationTime' has a wrong offset!");
static_assert(offsetof(UCharacterMovementComponent, NetProxyShrinkRadius) == 0x0003EC, "Member 'UCharacterMovementComponent::NetProxyShrinkRadius' has a wrong offset!");
static_assert(offsetof(UCharacterMovementComponent, NetProxyShrinkHalfHeight) == 0x0003F0, "Member 'UCharacterMovementComponent::NetProxyShrinkHalfHeight' has a wrong offset!");
static_assert(offsetof(UCharacterMovementComponent, NetworkMaxSmoothUpdateDistance) == 0x0003F4, "Member 'UCharacterMovementComponent::NetworkMaxSmoothUpdateDistance' has a wrong offset!");
static_assert(offsetof(UCharacterMovementComponent, NetworkNoSmoothUpdateDistance) == 0x0003F8, "Member 'UCharacterMovementComponent::NetworkNoSmoothUpdateDistance' has a wrong offset!");
static_assert(offsetof(UCharacterMovementComponent, NetworkMinTimeBetweenClientAckGoodMoves) == 0x0003FC, "Member 'UCharacterMovementComponent::NetworkMinTimeBetweenClientAckGoodMoves' has a wrong offset!");
static_assert(offsetof(UCharacterMovementComponent, NetworkMinTimeBetweenClientAdjustments) == 0x000400, "Member 'UCharacterMovementComponent::NetworkMinTimeBetweenClientAdjustments' has a wrong offset!");
static_assert(offsetof(UCharacterMovementComponent, NetworkMinTimeBetweenClientAdjustmentsLargeCorrection) == 0x000404, "Member 'UCharacterMovementComponent::NetworkMinTimeBetweenClientAdjustmentsLargeCorrection' has a wrong offset!");
static_assert(offsetof(UCharacterMovementComponent, NetworkLargeClientCorrectionDistance) == 0x000408, "Member 'UCharacterMovementComponent::NetworkLargeClientCorrectionDistance' has a wrong offset!");
static_assert(offsetof(UCharacterMovementComponent, LedgeCheckThreshold) == 0x00040C, "Member 'UCharacterMovementComponent::LedgeCheckThreshold' has a wrong offset!");
static_assert(offsetof(UCharacterMovementComponent, JumpOutOfWaterPitch) == 0x000410, "Member 'UCharacterMovementComponent::JumpOutOfWaterPitch' has a wrong offset!");
static_assert(offsetof(UCharacterMovementComponent, CurrentFloor) == 0x000418, "Member 'UCharacterMovementComponent::CurrentFloor' has a wrong offset!");
static_assert(offsetof(UCharacterMovementComponent, DefaultLandMovementMode) == 0x000510, "Member 'UCharacterMovementComponent::DefaultLandMovementMode' has a wrong offset!");
static_assert(offsetof(UCharacterMovementComponent, DefaultWaterMovementMode) == 0x000511, "Member 'UCharacterMovementComponent::DefaultWaterMovementMode' has a wrong offset!");
static_assert(offsetof(UCharacterMovementComponent, GroundMovementMode) == 0x000512, "Member 'UCharacterMovementComponent::GroundMovementMode' has a wrong offset!");
static_assert(offsetof(UCharacterMovementComponent, FormerBaseVelocityDecayHalfLife) == 0x000520, "Member 'UCharacterMovementComponent::FormerBaseVelocityDecayHalfLife' has a wrong offset!");
static_assert(offsetof(UCharacterMovementComponent, AvoidanceConsiderationRadius) == 0x000544, "Member 'UCharacterMovementComponent::AvoidanceConsiderationRadius' has a wrong offset!");
static_assert(offsetof(UCharacterMovementComponent, RequestedVelocity) == 0x000548, "Member 'UCharacterMovementComponent::RequestedVelocity' has a wrong offset!");
static_assert(offsetof(UCharacterMovementComponent, LastUpdateRequestedVelocity) == 0x000560, "Member 'UCharacterMovementComponent::LastUpdateRequestedVelocity' has a wrong offset!");
static_assert(offsetof(UCharacterMovementComponent, AvoidanceUID) == 0x000578, "Member 'UCharacterMovementComponent::AvoidanceUID' has a wrong offset!");
static_assert(offsetof(UCharacterMovementComponent, AvoidanceGroup) == 0x00057C, "Member 'UCharacterMovementComponent::AvoidanceGroup' has a wrong offset!");
static_assert(offsetof(UCharacterMovementComponent, GroupsToAvoid) == 0x000580, "Member 'UCharacterMovementComponent::GroupsToAvoid' has a wrong offset!");
static_assert(offsetof(UCharacterMovementComponent, GroupsToIgnore) == 0x000584, "Member 'UCharacterMovementComponent::GroupsToIgnore' has a wrong offset!");
static_assert(offsetof(UCharacterMovementComponent, AvoidanceWeight) == 0x000588, "Member 'UCharacterMovementComponent::AvoidanceWeight' has a wrong offset!");
static_assert(offsetof(UCharacterMovementComponent, PendingLaunchVelocity) == 0x000590, "Member 'UCharacterMovementComponent::PendingLaunchVelocity' has a wrong offset!");
static_assert(offsetof(UCharacterMovementComponent, NavMeshProjectionInterval) == 0x0006E0, "Member 'UCharacterMovementComponent::NavMeshProjectionInterval' has a wrong offset!");
static_assert(offsetof(UCharacterMovementComponent, NavMeshProjectionTimer) == 0x0006E4, "Member 'UCharacterMovementComponent::NavMeshProjectionTimer' has a wrong offset!");
static_assert(offsetof(UCharacterMovementComponent, NavMeshProjectionInterpSpeed) == 0x0006E8, "Member 'UCharacterMovementComponent::NavMeshProjectionInterpSpeed' has a wrong offset!");
static_assert(offsetof(UCharacterMovementComponent, NavMeshProjectionHeightScaleUp) == 0x0006EC, "Member 'UCharacterMovementComponent::NavMeshProjectionHeightScaleUp' has a wrong offset!");
static_assert(offsetof(UCharacterMovementComponent, NavMeshProjectionHeightScaleDown) == 0x0006F0, "Member 'UCharacterMovementComponent::NavMeshProjectionHeightScaleDown' has a wrong offset!");
static_assert(offsetof(UCharacterMovementComponent, NavWalkingFloorDistTolerance) == 0x0006F4, "Member 'UCharacterMovementComponent::NavWalkingFloorDistTolerance' has a wrong offset!");
static_assert(offsetof(UCharacterMovementComponent, PostPhysicsTickFunction) == 0x000730, "Member 'UCharacterMovementComponent::PostPhysicsTickFunction' has a wrong offset!");
static_assert(offsetof(UCharacterMovementComponent, MinTimeBetweenTimeStampResets) == 0x000780, "Member 'UCharacterMovementComponent::MinTimeBetweenTimeStampResets' has a wrong offset!");
static_assert(offsetof(UCharacterMovementComponent, CurrentRootMotion) == 0x000CD0, "Member 'UCharacterMovementComponent::CurrentRootMotion' has a wrong offset!");
static_assert(offsetof(UCharacterMovementComponent, ServerCorrectionRootMotion) == 0x000D18, "Member 'UCharacterMovementComponent::ServerCorrectionRootMotion' has a wrong offset!");
static_assert(offsetof(UCharacterMovementComponent, RootMotionParams) == 0x000EC0, "Member 'UCharacterMovementComponent::RootMotionParams' has a wrong offset!");
static_assert(offsetof(UCharacterMovementComponent, AnimRootMotionVelocity) == 0x000F30, "Member 'UCharacterMovementComponent::AnimRootMotionVelocity' has a wrong offset!");

// Class Engine.Interface_PostProcessVolume
// 0x0000 (0x0000 - 0x0000)
class IInterface_PostProcessVolume final
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"Interface_PostProcessVolume">();
	}
	static class IInterface_PostProcessVolume* GetDefaultObj()
	{
		return GetDefaultObjImpl<IInterface_PostProcessVolume>();
	}

	class UObject* AsUObject()
	{
		return reinterpret_cast<UObject*>(this);
	}
	const class UObject* AsUObject() const
	{
		return reinterpret_cast<const UObject*>(this);
	}
};
static_assert(alignof(IInterface_PostProcessVolume) == 0x000001, "Wrong alignment on IInterface_PostProcessVolume");
static_assert(sizeof(IInterface_PostProcessVolume) == 0x000001, "Wrong size on IInterface_PostProcessVolume");

// Class Engine.Interface_PreviewMeshProvider
// 0x0000 (0x0000 - 0x0000)
class IInterface_PreviewMeshProvider final
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"Interface_PreviewMeshProvider">();
	}
	static class IInterface_PreviewMeshProvider* GetDefaultObj()
	{
		return GetDefaultObjImpl<IInterface_PreviewMeshProvider>();
	}

	class UObject* AsUObject()
	{
		return reinterpret_cast<UObject*>(this);
	}
	const class UObject* AsUObject() const
	{
		return reinterpret_cast<const UObject*>(this);
	}
};
static_assert(alignof(IInterface_PreviewMeshProvider) == 0x000001, "Wrong alignment on IInterface_PreviewMeshProvider");
static_assert(sizeof(IInterface_PreviewMeshProvider) == 0x000001, "Wrong size on IInterface_PreviewMeshProvider");

// Class Engine.MaterialExpressionPerInstanceCustomData
// 0x0030 (0x00E0 - 0x00B0)
class UMaterialExpressionPerInstanceCustomData final : public UMaterialExpression
{
public:
	struct FExpressionInput                       DefaultValue;                                      // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	float                                         ConstDefaultValue;                                 // 0x00D8(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint32                                        DataIndex;                                         // 0x00DC(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionPerInstanceCustomData">();
	}
	static class UMaterialExpressionPerInstanceCustomData* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionPerInstanceCustomData>();
	}
};
static_assert(alignof(UMaterialExpressionPerInstanceCustomData) == 0x000008, "Wrong alignment on UMaterialExpressionPerInstanceCustomData");
static_assert(sizeof(UMaterialExpressionPerInstanceCustomData) == 0x0000E0, "Wrong size on UMaterialExpressionPerInstanceCustomData");
static_assert(offsetof(UMaterialExpressionPerInstanceCustomData, DefaultValue) == 0x0000B0, "Member 'UMaterialExpressionPerInstanceCustomData::DefaultValue' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionPerInstanceCustomData, ConstDefaultValue) == 0x0000D8, "Member 'UMaterialExpressionPerInstanceCustomData::ConstDefaultValue' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionPerInstanceCustomData, DataIndex) == 0x0000DC, "Member 'UMaterialExpressionPerInstanceCustomData::DataIndex' has a wrong offset!");

// Class Engine.ParticleModuleColorBase
// 0x0000 (0x0030 - 0x0030)
class UParticleModuleColorBase : public UParticleModule
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ParticleModuleColorBase">();
	}
	static class UParticleModuleColorBase* GetDefaultObj()
	{
		return GetDefaultObjImpl<UParticleModuleColorBase>();
	}
};
static_assert(alignof(UParticleModuleColorBase) == 0x000008, "Wrong alignment on UParticleModuleColorBase");
static_assert(sizeof(UParticleModuleColorBase) == 0x000030, "Wrong size on UParticleModuleColorBase");

// Class Engine.ParticleModuleColor
// 0x0098 (0x00C8 - 0x0030)
class UParticleModuleColor : public UParticleModuleColorBase
{
public:
	struct FRawDistributionVector                 StartColor;                                        // 0x0030(0x0060)(Edit, ContainsInstancedReference, NativeAccessSpecifierPublic)
	struct FRawDistributionFloat                  StartAlpha;                                        // 0x0090(0x0030)(Edit, ContainsInstancedReference, NativeAccessSpecifierPublic)
	uint8                                         bClampAlpha : 1;                                   // 0x00C0(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_C1[0x7];                                       // 0x00C1(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ParticleModuleColor">();
	}
	static class UParticleModuleColor* GetDefaultObj()
	{
		return GetDefaultObjImpl<UParticleModuleColor>();
	}
};
static_assert(alignof(UParticleModuleColor) == 0x000008, "Wrong alignment on UParticleModuleColor");
static_assert(sizeof(UParticleModuleColor) == 0x0000C8, "Wrong size on UParticleModuleColor");
static_assert(offsetof(UParticleModuleColor, StartColor) == 0x000030, "Member 'UParticleModuleColor::StartColor' has a wrong offset!");
static_assert(offsetof(UParticleModuleColor, StartAlpha) == 0x000090, "Member 'UParticleModuleColor::StartAlpha' has a wrong offset!");

// Class Engine.ParticleModuleColor_Seeded
// 0x0020 (0x00E8 - 0x00C8)
class UParticleModuleColor_Seeded final : public UParticleModuleColor
{
public:
	struct FParticleRandomSeedInfo                RandomSeedInfo;                                    // 0x00C8(0x0020)(Edit, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ParticleModuleColor_Seeded">();
	}
	static class UParticleModuleColor_Seeded* GetDefaultObj()
	{
		return GetDefaultObjImpl<UParticleModuleColor_Seeded>();
	}
};
static_assert(alignof(UParticleModuleColor_Seeded) == 0x000008, "Wrong alignment on UParticleModuleColor_Seeded");
static_assert(sizeof(UParticleModuleColor_Seeded) == 0x0000E8, "Wrong size on UParticleModuleColor_Seeded");
static_assert(offsetof(UParticleModuleColor_Seeded, RandomSeedInfo) == 0x0000C8, "Member 'UParticleModuleColor_Seeded::RandomSeedInfo' has a wrong offset!");

// Class Engine.PhysicsComponent
// 0x0000 (0x0000 - 0x0000)
class IPhysicsComponent final
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"PhysicsComponent">();
	}
	static class IPhysicsComponent* GetDefaultObj()
	{
		return GetDefaultObjImpl<IPhysicsComponent>();
	}

	class UObject* AsUObject()
	{
		return reinterpret_cast<UObject*>(this);
	}
	const class UObject* AsUObject() const
	{
		return reinterpret_cast<const UObject*>(this);
	}
};
static_assert(alignof(IPhysicsComponent) == 0x000001, "Wrong alignment on IPhysicsComponent");
static_assert(sizeof(IPhysicsComponent) == 0x000001, "Wrong size on IPhysicsComponent");

// Class Engine.CurveBase
// 0x0008 (0x0030 - 0x0028)
class UCurveBase : public UObject
{
public:
	uint8                                         Pad_28[0x8];                                       // 0x0028(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void GetTimeRange(float* MinTime, float* MaxTime) const;
	void GetValueRange(float* MinValue, float* MaxValue) const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"CurveBase">();
	}
	static class UCurveBase* GetDefaultObj()
	{
		return GetDefaultObjImpl<UCurveBase>();
	}
};
static_assert(alignof(UCurveBase) == 0x000008, "Wrong alignment on UCurveBase");
static_assert(sizeof(UCurveBase) == 0x000030, "Wrong size on UCurveBase");

// Class Engine.CurveVector
// 0x0180 (0x01B0 - 0x0030)
class UCurveVector final : public UCurveBase
{
public:
	struct FRichCurve                             FloatCurves[0x3];                                  // 0x0030(0x0080)(NativeAccessSpecifierPublic)

public:
	struct FVector GetVectorValue(float InTime) const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"CurveVector">();
	}
	static class UCurveVector* GetDefaultObj()
	{
		return GetDefaultObjImpl<UCurveVector>();
	}
};
static_assert(alignof(UCurveVector) == 0x000008, "Wrong alignment on UCurveVector");
static_assert(sizeof(UCurveVector) == 0x0001B0, "Wrong size on UCurveVector");
static_assert(offsetof(UCurveVector, FloatCurves) == 0x000030, "Member 'UCurveVector::FloatCurves' has a wrong offset!");

// Class Engine.MaterialExpressionPixelNormalWS
// 0x0000 (0x00B0 - 0x00B0)
class UMaterialExpressionPixelNormalWS final : public UMaterialExpression
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionPixelNormalWS">();
	}
	static class UMaterialExpressionPixelNormalWS* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionPixelNormalWS>();
	}
};
static_assert(alignof(UMaterialExpressionPixelNormalWS) == 0x000008, "Wrong alignment on UMaterialExpressionPixelNormalWS");
static_assert(sizeof(UMaterialExpressionPixelNormalWS) == 0x0000B0, "Wrong size on UMaterialExpressionPixelNormalWS");

// Class Engine.ISMPartitionInstanceManager
// 0x0000 (0x0000 - 0x0000)
class IISMPartitionInstanceManager final
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ISMPartitionInstanceManager">();
	}
	static class IISMPartitionInstanceManager* GetDefaultObj()
	{
		return GetDefaultObjImpl<IISMPartitionInstanceManager>();
	}

	class UObject* AsUObject()
	{
		return reinterpret_cast<UObject*>(this);
	}
	const class UObject* AsUObject() const
	{
		return reinterpret_cast<const UObject*>(this);
	}
};
static_assert(alignof(IISMPartitionInstanceManager) == 0x000001, "Wrong alignment on IISMPartitionInstanceManager");
static_assert(sizeof(IISMPartitionInstanceManager) == 0x000001, "Wrong size on IISMPartitionInstanceManager");

// Class Engine.ParticleModuleKillBase
// 0x0000 (0x0030 - 0x0030)
class UParticleModuleKillBase : public UParticleModule
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ParticleModuleKillBase">();
	}
	static class UParticleModuleKillBase* GetDefaultObj()
	{
		return GetDefaultObjImpl<UParticleModuleKillBase>();
	}
};
static_assert(alignof(UParticleModuleKillBase) == 0x000008, "Wrong alignment on UParticleModuleKillBase");
static_assert(sizeof(UParticleModuleKillBase) == 0x000030, "Wrong size on UParticleModuleKillBase");

// Class Engine.ParticleModuleKillHeight
// 0x0038 (0x0068 - 0x0030)
class UParticleModuleKillHeight final : public UParticleModuleKillBase
{
public:
	struct FRawDistributionFloat                  Height;                                            // 0x0030(0x0030)(Edit, ContainsInstancedReference, NativeAccessSpecifierPublic)
	uint8                                         bAbsolute : 1;                                     // 0x0060(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bFloor : 1;                                        // 0x0060(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bApplyPSysScale : 1;                               // 0x0060(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_61[0x7];                                       // 0x0061(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ParticleModuleKillHeight">();
	}
	static class UParticleModuleKillHeight* GetDefaultObj()
	{
		return GetDefaultObjImpl<UParticleModuleKillHeight>();
	}
};
static_assert(alignof(UParticleModuleKillHeight) == 0x000008, "Wrong alignment on UParticleModuleKillHeight");
static_assert(sizeof(UParticleModuleKillHeight) == 0x000068, "Wrong size on UParticleModuleKillHeight");
static_assert(offsetof(UParticleModuleKillHeight, Height) == 0x000030, "Member 'UParticleModuleKillHeight::Height' has a wrong offset!");

// Class Engine.ParticleModuleAttractorLine
// 0x0090 (0x00C0 - 0x0030)
class UParticleModuleAttractorLine final : public UParticleModuleAttractorBase
{
public:
	struct FVector                                EndPoint0;                                         // 0x0030(0x0018)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector                                EndPoint1;                                         // 0x0048(0x0018)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FRawDistributionFloat                  Range;                                             // 0x0060(0x0030)(Edit, ContainsInstancedReference, NativeAccessSpecifierPublic)
	struct FRawDistributionFloat                  Strength;                                          // 0x0090(0x0030)(Edit, ContainsInstancedReference, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ParticleModuleAttractorLine">();
	}
	static class UParticleModuleAttractorLine* GetDefaultObj()
	{
		return GetDefaultObjImpl<UParticleModuleAttractorLine>();
	}
};
static_assert(alignof(UParticleModuleAttractorLine) == 0x000008, "Wrong alignment on UParticleModuleAttractorLine");
static_assert(sizeof(UParticleModuleAttractorLine) == 0x0000C0, "Wrong size on UParticleModuleAttractorLine");
static_assert(offsetof(UParticleModuleAttractorLine, EndPoint0) == 0x000030, "Member 'UParticleModuleAttractorLine::EndPoint0' has a wrong offset!");
static_assert(offsetof(UParticleModuleAttractorLine, EndPoint1) == 0x000048, "Member 'UParticleModuleAttractorLine::EndPoint1' has a wrong offset!");
static_assert(offsetof(UParticleModuleAttractorLine, Range) == 0x000060, "Member 'UParticleModuleAttractorLine::Range' has a wrong offset!");
static_assert(offsetof(UParticleModuleAttractorLine, Strength) == 0x000090, "Member 'UParticleModuleAttractorLine::Strength' has a wrong offset!");

// Class Engine.ISMPartitionInstanceManagerProvider
// 0x0000 (0x0000 - 0x0000)
class IISMPartitionInstanceManagerProvider final
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ISMPartitionInstanceManagerProvider">();
	}
	static class IISMPartitionInstanceManagerProvider* GetDefaultObj()
	{
		return GetDefaultObjImpl<IISMPartitionInstanceManagerProvider>();
	}

	class UObject* AsUObject()
	{
		return reinterpret_cast<UObject*>(this);
	}
	const class UObject* AsUObject() const
	{
		return reinterpret_cast<const UObject*>(this);
	}
};
static_assert(alignof(IISMPartitionInstanceManagerProvider) == 0x000001, "Wrong alignment on IISMPartitionInstanceManagerProvider");
static_assert(sizeof(IISMPartitionInstanceManagerProvider) == 0x000001, "Wrong size on IISMPartitionInstanceManagerProvider");

// Class Engine.ReporterBase
// 0x0008 (0x0030 - 0x0028)
class UReporterBase : public UObject
{
public:
	uint8                                         Pad_28[0x8];                                       // 0x0028(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ReporterBase">();
	}
	static class UReporterBase* GetDefaultObj()
	{
		return GetDefaultObjImpl<UReporterBase>();
	}
};
static_assert(alignof(UReporterBase) == 0x000008, "Wrong alignment on UReporterBase");
static_assert(sizeof(UReporterBase) == 0x000030, "Wrong size on UReporterBase");

// Class Engine.MaterialExpressionSingleLayerWaterMaterialOutput
// 0x00A0 (0x0150 - 0x00B0)
class UMaterialExpressionSingleLayerWaterMaterialOutput final : public UMaterialExpressionCustomOutput
{
public:
	struct FExpressionInput                       ScatteringCoefficients;                            // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       AbsorptionCoefficients;                            // 0x00D8(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       PhaseG;                                            // 0x0100(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       ColorScaleBehindWater;                             // 0x0128(0x0028)(NoDestructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionSingleLayerWaterMaterialOutput">();
	}
	static class UMaterialExpressionSingleLayerWaterMaterialOutput* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionSingleLayerWaterMaterialOutput>();
	}
};
static_assert(alignof(UMaterialExpressionSingleLayerWaterMaterialOutput) == 0x000008, "Wrong alignment on UMaterialExpressionSingleLayerWaterMaterialOutput");
static_assert(sizeof(UMaterialExpressionSingleLayerWaterMaterialOutput) == 0x000150, "Wrong size on UMaterialExpressionSingleLayerWaterMaterialOutput");
static_assert(offsetof(UMaterialExpressionSingleLayerWaterMaterialOutput, ScatteringCoefficients) == 0x0000B0, "Member 'UMaterialExpressionSingleLayerWaterMaterialOutput::ScatteringCoefficients' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionSingleLayerWaterMaterialOutput, AbsorptionCoefficients) == 0x0000D8, "Member 'UMaterialExpressionSingleLayerWaterMaterialOutput::AbsorptionCoefficients' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionSingleLayerWaterMaterialOutput, PhaseG) == 0x000100, "Member 'UMaterialExpressionSingleLayerWaterMaterialOutput::PhaseG' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionSingleLayerWaterMaterialOutput, ColorScaleBehindWater) == 0x000128, "Member 'UMaterialExpressionSingleLayerWaterMaterialOutput::ColorScaleBehindWater' has a wrong offset!");

// Class Engine.WorldPartitionObjectResolver
// 0x0000 (0x0000 - 0x0000)
class IWorldPartitionObjectResolver final
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"WorldPartitionObjectResolver">();
	}
	static class IWorldPartitionObjectResolver* GetDefaultObj()
	{
		return GetDefaultObjImpl<IWorldPartitionObjectResolver>();
	}

	class UObject* AsUObject()
	{
		return reinterpret_cast<UObject*>(this);
	}
	const class UObject* AsUObject() const
	{
		return reinterpret_cast<const UObject*>(this);
	}
};
static_assert(alignof(IWorldPartitionObjectResolver) == 0x000001, "Wrong alignment on IWorldPartitionObjectResolver");
static_assert(sizeof(IWorldPartitionObjectResolver) == 0x000001, "Wrong size on IWorldPartitionObjectResolver");

// Class Engine.SkyAtmosphereComponent
// 0x0100 (0x03A0 - 0x02A0)
class USkyAtmosphereComponent : public USceneComponent
{
public:
	ESkyAtmosphereTransformMode                   TransformMode;                                     // 0x02A0(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_2A1[0x3];                                      // 0x02A1(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         BottomRadius;                                      // 0x02A4(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FColor                                 GroundAlbedo;                                      // 0x02A8(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         AtmosphereHeight;                                  // 0x02AC(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         MultiScatteringFactor;                             // 0x02B0(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         TraceSampleCountScale;                             // 0x02B4(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         RayleighScatteringScale;                           // 0x02B8(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FLinearColor                           RayleighScattering;                                // 0x02BC(0x0010)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         RayleighExponentialDistribution;                   // 0x02CC(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         MieScatteringScale;                                // 0x02D0(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FLinearColor                           MieScattering;                                     // 0x02D4(0x0010)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         MieAbsorptionScale;                                // 0x02E4(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FLinearColor                           MieAbsorption;                                     // 0x02E8(0x0010)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         MieAnisotropy;                                     // 0x02F8(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         MieExponentialDistribution;                        // 0x02FC(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         OtherAbsorptionScale;                              // 0x0300(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FLinearColor                           OtherAbsorption;                                   // 0x0304(0x0010)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FTentDistribution                      OtherTentDistribution;                             // 0x0314(0x000C)(Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, NativeAccessSpecifierPublic)
	struct FLinearColor                           SkyLuminanceFactor;                                // 0x0320(0x0010)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         AerialPespectiveViewDistanceScale;                 // 0x0330(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         HeightFogContribution;                             // 0x0334(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         TransmittanceMinLightElevationAngle;               // 0x0338(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         AerialPerspectiveStartDepth;                       // 0x033C(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_340[0x40];                                     // 0x0340(0x0040)(Fixing Size After Last Property [ Dumper-7 ])
	struct FGuid                                  bStaticLightingBuiltGUID;                          // 0x0380(0x0010)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_390[0x10];                                     // 0x0390(0x0010)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	struct FLinearColor GetAtmosphereTransmitanceOnGroundAtPlanetTop(class UDirectionalLightComponent* DirectionalLight);
	struct FVector GetOverridenAtmosphereLightDirection(int32 AtmosphereLightIndex);
	bool IsAtmosphereLightDirectionOverriden(int32 AtmosphereLightIndex);
	void OverrideAtmosphereLightDirection(int32 AtmosphereLightIndex, const struct FVector& LightDirection);
	void ResetAtmosphereLightDirectionOverride(int32 AtmosphereLightIndex);
	void SetAerialPespectiveViewDistanceScale(float NewValue);
	void SetAtmosphereHeight(float NewValue);
	void SetBottomRadius(float NewValue);
	void SetGroundAlbedo(const struct FColor& NewValue);
	void SetHeightFogContribution(float NewValue);
	void SetMieAbsorption(const struct FLinearColor& NewValue);
	void SetMieAbsorptionScale(float NewValue);
	void SetMieAnisotropy(float NewValue);
	void SetMieExponentialDistribution(float NewValue);
	void SetMieScattering(const struct FLinearColor& NewValue);
	void SetMieScatteringScale(float NewValue);
	void SetMultiScatteringFactor(float NewValue);
	void SetOtherAbsorption(const struct FLinearColor& NewValue);
	void SetOtherAbsorptionScale(float NewValue);
	void SetRayleighExponentialDistribution(float NewValue);
	void SetRayleighScattering(const struct FLinearColor& NewValue);
	void SetRayleighScatteringScale(float NewValue);
	void SetSkyLuminanceFactor(const struct FLinearColor& NewValue);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"SkyAtmosphereComponent">();
	}
	static class USkyAtmosphereComponent* GetDefaultObj()
	{
		return GetDefaultObjImpl<USkyAtmosphereComponent>();
	}
};
static_assert(alignof(USkyAtmosphereComponent) == 0x000010, "Wrong alignment on USkyAtmosphereComponent");
static_assert(sizeof(USkyAtmosphereComponent) == 0x0003A0, "Wrong size on USkyAtmosphereComponent");
static_assert(offsetof(USkyAtmosphereComponent, TransformMode) == 0x0002A0, "Member 'USkyAtmosphereComponent::TransformMode' has a wrong offset!");
static_assert(offsetof(USkyAtmosphereComponent, BottomRadius) == 0x0002A4, "Member 'USkyAtmosphereComponent::BottomRadius' has a wrong offset!");
static_assert(offsetof(USkyAtmosphereComponent, GroundAlbedo) == 0x0002A8, "Member 'USkyAtmosphereComponent::GroundAlbedo' has a wrong offset!");
static_assert(offsetof(USkyAtmosphereComponent, AtmosphereHeight) == 0x0002AC, "Member 'USkyAtmosphereComponent::AtmosphereHeight' has a wrong offset!");
static_assert(offsetof(USkyAtmosphereComponent, MultiScatteringFactor) == 0x0002B0, "Member 'USkyAtmosphereComponent::MultiScatteringFactor' has a wrong offset!");
static_assert(offsetof(USkyAtmosphereComponent, TraceSampleCountScale) == 0x0002B4, "Member 'USkyAtmosphereComponent::TraceSampleCountScale' has a wrong offset!");
static_assert(offsetof(USkyAtmosphereComponent, RayleighScatteringScale) == 0x0002B8, "Member 'USkyAtmosphereComponent::RayleighScatteringScale' has a wrong offset!");
static_assert(offsetof(USkyAtmosphereComponent, RayleighScattering) == 0x0002BC, "Member 'USkyAtmosphereComponent::RayleighScattering' has a wrong offset!");
static_assert(offsetof(USkyAtmosphereComponent, RayleighExponentialDistribution) == 0x0002CC, "Member 'USkyAtmosphereComponent::RayleighExponentialDistribution' has a wrong offset!");
static_assert(offsetof(USkyAtmosphereComponent, MieScatteringScale) == 0x0002D0, "Member 'USkyAtmosphereComponent::MieScatteringScale' has a wrong offset!");
static_assert(offsetof(USkyAtmosphereComponent, MieScattering) == 0x0002D4, "Member 'USkyAtmosphereComponent::MieScattering' has a wrong offset!");
static_assert(offsetof(USkyAtmosphereComponent, MieAbsorptionScale) == 0x0002E4, "Member 'USkyAtmosphereComponent::MieAbsorptionScale' has a wrong offset!");
static_assert(offsetof(USkyAtmosphereComponent, MieAbsorption) == 0x0002E8, "Member 'USkyAtmosphereComponent::MieAbsorption' has a wrong offset!");
static_assert(offsetof(USkyAtmosphereComponent, MieAnisotropy) == 0x0002F8, "Member 'USkyAtmosphereComponent::MieAnisotropy' has a wrong offset!");
static_assert(offsetof(USkyAtmosphereComponent, MieExponentialDistribution) == 0x0002FC, "Member 'USkyAtmosphereComponent::MieExponentialDistribution' has a wrong offset!");
static_assert(offsetof(USkyAtmosphereComponent, OtherAbsorptionScale) == 0x000300, "Member 'USkyAtmosphereComponent::OtherAbsorptionScale' has a wrong offset!");
static_assert(offsetof(USkyAtmosphereComponent, OtherAbsorption) == 0x000304, "Member 'USkyAtmosphereComponent::OtherAbsorption' has a wrong offset!");
static_assert(offsetof(USkyAtmosphereComponent, OtherTentDistribution) == 0x000314, "Member 'USkyAtmosphereComponent::OtherTentDistribution' has a wrong offset!");
static_assert(offsetof(USkyAtmosphereComponent, SkyLuminanceFactor) == 0x000320, "Member 'USkyAtmosphereComponent::SkyLuminanceFactor' has a wrong offset!");
static_assert(offsetof(USkyAtmosphereComponent, AerialPespectiveViewDistanceScale) == 0x000330, "Member 'USkyAtmosphereComponent::AerialPespectiveViewDistanceScale' has a wrong offset!");
static_assert(offsetof(USkyAtmosphereComponent, HeightFogContribution) == 0x000334, "Member 'USkyAtmosphereComponent::HeightFogContribution' has a wrong offset!");
static_assert(offsetof(USkyAtmosphereComponent, TransmittanceMinLightElevationAngle) == 0x000338, "Member 'USkyAtmosphereComponent::TransmittanceMinLightElevationAngle' has a wrong offset!");
static_assert(offsetof(USkyAtmosphereComponent, AerialPerspectiveStartDepth) == 0x00033C, "Member 'USkyAtmosphereComponent::AerialPerspectiveStartDepth' has a wrong offset!");
static_assert(offsetof(USkyAtmosphereComponent, bStaticLightingBuiltGUID) == 0x000380, "Member 'USkyAtmosphereComponent::bStaticLightingBuiltGUID' has a wrong offset!");

// Class Engine.AtmosphericFogComponent
// 0x0000 (0x03A0 - 0x03A0)
class UAtmosphericFogComponent final : public USkyAtmosphereComponent
{
public:
	void DisableGroundScattering(bool NewGroundScattering);
	void DisableSunDisk(bool NewSunDisk);
	void SetAltitudeScale(float NewAltitudeScale);
	void SetDefaultBrightness(float NewBrightness);
	void SetDefaultLightColor(const struct FLinearColor& NewLightColor);
	void SetDensityMultiplier(float NewDensityMultiplier);
	void SetDensityOffset(float NewDensityOffset);
	void SetDistanceOffset(float NewDistanceOffset);
	void SetDistanceScale(float NewDistanceScale);
	void SetFogMultiplier(float NewFogMultiplier);
	void SetPrecomputeParams(float DensityHeight, int32 MaxScatteringOrder, int32 InscatterAltitudeSampleNum);
	void SetStartDistance(float NewStartDistance);
	void SetSunMultiplier(float NewSunMultiplier);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AtmosphericFogComponent">();
	}
	static class UAtmosphericFogComponent* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAtmosphericFogComponent>();
	}
};
static_assert(alignof(UAtmosphericFogComponent) == 0x000010, "Wrong alignment on UAtmosphericFogComponent");
static_assert(sizeof(UAtmosphericFogComponent) == 0x0003A0, "Wrong size on UAtmosphericFogComponent");

// Class Engine.KismetTextLibrary
// 0x0000 (0x0028 - 0x0028)
class UKismetTextLibrary final : public UBlueprintFunctionLibrary
{
public:
	static class FText AsCurrency_Float(float Value, ERoundingMode RoundingMode, bool bAlwaysSign, bool bUseGrouping, int32 MinimumIntegralDigits, int32 MaximumIntegralDigits, int32 MinimumFractionalDigits, int32 MaximumFractionalDigits, const class FString& CurrencyCode);
	static class FText AsCurrency_Integer(int32 Value, ERoundingMode RoundingMode, bool bAlwaysSign, bool bUseGrouping, int32 MinimumIntegralDigits, int32 MaximumIntegralDigits, int32 MinimumFractionalDigits, int32 MaximumFractionalDigits, const class FString& CurrencyCode);
	static class FText AsCurrencyBase(int32 BaseValue, const class FString& CurrencyCode);
	static class FText AsDate_DateTime(const struct FDateTime& InDateTime);
	static class FText AsDateTime_DateTime(const struct FDateTime& In);
	static class FText AsPercent_Float(float Value, ERoundingMode RoundingMode, bool bAlwaysSign, bool bUseGrouping, int32 MinimumIntegralDigits, int32 MaximumIntegralDigits, int32 MinimumFractionalDigits, int32 MaximumFractionalDigits);
	static class FText AsTime_DateTime(const struct FDateTime& In);
	static class FText AsTimespan_Timespan(const struct FTimespan& InTimespan);
	static class FText AsTimeZoneDate_DateTime(const struct FDateTime& InDateTime, const class FString& InTimeZone);
	static class FText AsTimeZoneDateTime_DateTime(const struct FDateTime& InDateTime, const class FString& InTimeZone);
	static class FText AsTimeZoneTime_DateTime(const struct FDateTime& InDateTime, const class FString& InTimeZone);
	static class FText Conv_BoolToText(bool InBool);
	static class FText Conv_ByteToText(uint8 Value);
	static class FText Conv_ColorToText(const struct FLinearColor& InColor);
	static class FText Conv_DoubleToText(double Value, ERoundingMode RoundingMode, bool bAlwaysSign, bool bUseGrouping, int32 MinimumIntegralDigits, int32 MaximumIntegralDigits, int32 MinimumFractionalDigits, int32 MaximumFractionalDigits);
	static class FText Conv_Int64ToText(int64 Value, bool bAlwaysSign, bool bUseGrouping, int32 MinimumIntegralDigits, int32 MaximumIntegralDigits);
	static class FText Conv_IntToText(int32 Value, bool bAlwaysSign, bool bUseGrouping, int32 MinimumIntegralDigits, int32 MaximumIntegralDigits);
	static class FText Conv_NameToText(class FName InName);
	static class FText Conv_ObjectToText(class UObject* InObj);
	static class FText Conv_RotatorToText(const struct FRotator& InRot);
	static class FText Conv_StringToText(const class FString& InString);
	static class FString Conv_TextToString(const class FText& InText);
	static class FText Conv_TransformToText(const struct FTransform& InTrans);
	static class FText Conv_Vector2dToText(const struct FVector2D& InVec);
	static class FText Conv_VectorToText(const struct FVector& InVec);
	static bool EqualEqual_IgnoreCase_TextText(const class FText& A, const class FText& B);
	static bool EqualEqual_TextText(const class FText& A, const class FText& B);
	static bool FindTextInLocalizationTable(const class FString& Namespace, const class FString& Key, class FText* OutText, const class FString& SourceString);
	static class FText Format(const class FText& InPattern, const TArray<struct FFormatArgumentData>& InArgs);
	static class FText GetEmptyText();
	static void IsPolyglotDataValid(const struct FPolyglotTextData& PolyglotData, bool* IsValid, class FText* ErrorMessage);
	static bool NotEqual_IgnoreCase_TextText(const class FText& A, const class FText& B);
	static bool NotEqual_TextText(const class FText& A, const class FText& B);
	static class FText PolyglotDataToText(const struct FPolyglotTextData& PolyglotData);
	static bool StringTableIdAndKeyFromText(const class FText& Text, class FName* OutTableId, class FString* OutKey);
	static class FText TextFromStringTable(const class FName TableId, const class FString& Key);
	static bool TextIsCultureInvariant(const class FText& InText);
	static bool TextIsEmpty(const class FText& InText);
	static bool TextIsFromStringTable(const class FText& Text);
	static bool TextIsTransient(const class FText& InText);
	static class FText TextToLower(const class FText& InText);
	static class FText TextToUpper(const class FText& InText);
	static class FText TextTrimPreceding(const class FText& InText);
	static class FText TextTrimPrecedingAndTrailing(const class FText& InText);
	static class FText TextTrimTrailing(const class FText& InText);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"KismetTextLibrary">();
	}
	static class UKismetTextLibrary* GetDefaultObj()
	{
		return GetDefaultObjImpl<UKismetTextLibrary>();
	}
};
static_assert(alignof(UKismetTextLibrary) == 0x000008, "Wrong alignment on UKismetTextLibrary");
static_assert(sizeof(UKismetTextLibrary) == 0x000028, "Wrong size on UKismetTextLibrary");

// Class Engine.SubsystemBlueprintLibrary
// 0x0000 (0x0028 - 0x0028)
class USubsystemBlueprintLibrary final : public UBlueprintFunctionLibrary
{
public:
	static class UAudioEngineSubsystem* GetAudioEngineSubsystem(class UObject* ContextObject, TSubclassOf<class UAudioEngineSubsystem> Class_0);
	static class UEngineSubsystem* GetEngineSubsystem(TSubclassOf<class UEngineSubsystem> Class_0);
	static class UGameInstanceSubsystem* GetGameInstanceSubsystem(class UObject* ContextObject, TSubclassOf<class UGameInstanceSubsystem> Class_0);
	static class ULocalPlayerSubsystem* GetLocalPlayerSubsystem(class UObject* ContextObject, TSubclassOf<class ULocalPlayerSubsystem> Class_0);
	static class ULocalPlayerSubsystem* GetLocalPlayerSubSystemFromPlayerController(class APlayerController* PlayerController, TSubclassOf<class ULocalPlayerSubsystem> Class_0);
	static class UWorldSubsystem* GetWorldSubsystem(class UObject* ContextObject, TSubclassOf<class UWorldSubsystem> Class_0);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"SubsystemBlueprintLibrary">();
	}
	static class USubsystemBlueprintLibrary* GetDefaultObj()
	{
		return GetDefaultObjImpl<USubsystemBlueprintLibrary>();
	}
};
static_assert(alignof(USubsystemBlueprintLibrary) == 0x000008, "Wrong alignment on USubsystemBlueprintLibrary");
static_assert(sizeof(USubsystemBlueprintLibrary) == 0x000028, "Wrong size on USubsystemBlueprintLibrary");

// Class Engine.MaterialExpressionLightmapUVs
// 0x0000 (0x00B0 - 0x00B0)
class UMaterialExpressionLightmapUVs final : public UMaterialExpression
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionLightmapUVs">();
	}
	static class UMaterialExpressionLightmapUVs* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionLightmapUVs>();
	}
};
static_assert(alignof(UMaterialExpressionLightmapUVs) == 0x000008, "Wrong alignment on UMaterialExpressionLightmapUVs");
static_assert(sizeof(UMaterialExpressionLightmapUVs) == 0x0000B0, "Wrong size on UMaterialExpressionLightmapUVs");

// Class Engine.LevelInstanceEditorPivotInterface
// 0x0000 (0x0000 - 0x0000)
class ILevelInstanceEditorPivotInterface final
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"LevelInstanceEditorPivotInterface">();
	}
	static class ILevelInstanceEditorPivotInterface* GetDefaultObj()
	{
		return GetDefaultObjImpl<ILevelInstanceEditorPivotInterface>();
	}

	class UObject* AsUObject()
	{
		return reinterpret_cast<UObject*>(this);
	}
	const class UObject* AsUObject() const
	{
		return reinterpret_cast<const UObject*>(this);
	}
};
static_assert(alignof(ILevelInstanceEditorPivotInterface) == 0x000001, "Wrong alignment on ILevelInstanceEditorPivotInterface");
static_assert(sizeof(ILevelInstanceEditorPivotInterface) == 0x000001, "Wrong size on ILevelInstanceEditorPivotInterface");

// Class Engine.ForceFeedbackComponent
// 0x00F0 (0x0390 - 0x02A0)
class UForceFeedbackComponent final : public USceneComponent
{
public:
	class UForceFeedbackEffect*                   ForceFeedbackEffect;                               // 0x02A0(0x0008)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bAutoDestroy : 1;                                  // 0x02A8(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bStopWhenOwnerDestroyed : 1;                       // 0x02A8(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bLooping : 1;                                      // 0x02A8(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bIgnoreTimeDilation : 1;                           // 0x02A8(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bOverrideAttenuation : 1;                          // 0x02A8(0x0001)(BitIndex: 0x04, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_2A9[0x3];                                      // 0x02A9(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         IntensityMultiplier;                               // 0x02AC(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UForceFeedbackAttenuation*              AttenuationSettings;                               // 0x02B0(0x0008)(Edit, BlueprintVisible, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FForceFeedbackAttenuationSettings      AttenuationOverrides;                              // 0x02B8(0x00C0)(Edit, BlueprintVisible, NativeAccessSpecifierPublic)
	TMulticastInlineDelegate<void(class UForceFeedbackComponent* ForceFeedbackComponent)> OnForceFeedbackFinished; // 0x0378(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	uint8                                         Pad_388[0x8];                                      // 0x0388(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void AdjustAttenuation(const struct FForceFeedbackAttenuationSettings& InAttenuationSettings);
	void Play(float startTime);
	void SetForceFeedbackEffect(class UForceFeedbackEffect* NewForceFeedbackEffect);
	void SetIntensityMultiplier(float NewIntensityMultiplier);
	void Stop();

	bool BP_GetAttenuationSettingsToApply(struct FForceFeedbackAttenuationSettings* OutAttenuationSettings) const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ForceFeedbackComponent">();
	}
	static class UForceFeedbackComponent* GetDefaultObj()
	{
		return GetDefaultObjImpl<UForceFeedbackComponent>();
	}
};
static_assert(alignof(UForceFeedbackComponent) == 0x000010, "Wrong alignment on UForceFeedbackComponent");
static_assert(sizeof(UForceFeedbackComponent) == 0x000390, "Wrong size on UForceFeedbackComponent");
static_assert(offsetof(UForceFeedbackComponent, ForceFeedbackEffect) == 0x0002A0, "Member 'UForceFeedbackComponent::ForceFeedbackEffect' has a wrong offset!");
static_assert(offsetof(UForceFeedbackComponent, IntensityMultiplier) == 0x0002AC, "Member 'UForceFeedbackComponent::IntensityMultiplier' has a wrong offset!");
static_assert(offsetof(UForceFeedbackComponent, AttenuationSettings) == 0x0002B0, "Member 'UForceFeedbackComponent::AttenuationSettings' has a wrong offset!");
static_assert(offsetof(UForceFeedbackComponent, AttenuationOverrides) == 0x0002B8, "Member 'UForceFeedbackComponent::AttenuationOverrides' has a wrong offset!");
static_assert(offsetof(UForceFeedbackComponent, OnForceFeedbackFinished) == 0x000378, "Member 'UForceFeedbackComponent::OnForceFeedbackFinished' has a wrong offset!");

// Class Engine.World
// 0x08D0 (0x08F8 - 0x0028)
class UWorld final : public UObject
{
public:
	uint8                                         Pad_28[0x8];                                       // 0x0028(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	class ULevel*                                 PersistentLevel;                                   // 0x0030(0x0008)(ZeroConstructor, Transient, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UNetDriver*                             NetDriver;                                         // 0x0038(0x0008)(ZeroConstructor, Transient, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class ULineBatchComponent*                    LineBatcher;                                       // 0x0040(0x0008)(ExportObject, ZeroConstructor, Transient, InstancedReference, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class ULineBatchComponent*                    PersistentLineBatcher;                             // 0x0048(0x0008)(ExportObject, ZeroConstructor, Transient, InstancedReference, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class ULineBatchComponent*                    ForegroundLineBatcher;                             // 0x0050(0x0008)(ExportObject, ZeroConstructor, Transient, InstancedReference, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AGameNetworkManager*                    NetworkManager;                                    // 0x0058(0x0008)(ZeroConstructor, Transient, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UPhysicsCollisionHandler*               PhysicsCollisionHandler;                           // 0x0060(0x0008)(ZeroConstructor, Transient, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TArray<class UObject*>                        ExtraReferencedObjects;                            // 0x0068(0x0010)(ZeroConstructor, Transient, UObjectWrapper, NativeAccessSpecifierPublic)
	TArray<class UObject*>                        PerModuleDataObjects;                              // 0x0078(0x0010)(ZeroConstructor, Transient, UObjectWrapper, NativeAccessSpecifierPublic)
	TArray<class ULevelStreaming*>                StreamingLevels;                                   // 0x0088(0x0010)(ZeroConstructor, Transient, UObjectWrapper, NativeAccessSpecifierPrivate)
	struct FStreamingLevelsToConsider             StreamingLevelsToConsider;                         // 0x0098(0x0028)(Transient, DuplicateTransient, NativeAccessSpecifierPrivate)
	class AServerStreamingLevelsVisibility*       ServerStreamingLevelsVisibility;                   // 0x00C0(0x0008)(ZeroConstructor, Transient, DuplicateTransient, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	class FString                                 StreamingLevelsPrefix;                             // 0x00C8(0x0010)(ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_D8[0x8];                                       // 0x00D8(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	class ULevel*                                 CurrentLevelPendingVisibility;                     // 0x00E0(0x0008)(ZeroConstructor, Transient, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	class ULevel*                                 CurrentLevelPendingInvisibility;                   // 0x00E8(0x0008)(ZeroConstructor, Transient, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	class UDemoNetDriver*                         DemoNetDriver;                                     // 0x00F0(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	class AParticleEventManager*                  MyParticleEventManager;                            // 0x00F8(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class APhysicsVolume*                         DefaultPhysicsVolume;                              // 0x0100(0x0008)(ZeroConstructor, Transient, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_108[0x36];                                     // 0x0108(0x0036)(Fixing Size After Last Property [ Dumper-7 ])
	uint8                                         BitPad_13E_0 : 2;                                  // 0x013E(0x0001)(Fixing Bit-Field Size Between Bits [ Dumper-7 ])
	uint8                                         bAreConstraintsDirty : 1;                          // 0x013E(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Transient, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_13F[0x9];                                      // 0x013F(0x0009)(Fixing Size After Last Property [ Dumper-7 ])
	class UNavigationSystemBase*                  NavigationSystem;                                  // 0x0148(0x0008)(ZeroConstructor, Transient, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	class AGameModeBase*                          AuthorityGameMode;                                 // 0x0150(0x0008)(ZeroConstructor, Transient, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	class AGameStateBase*                         GameState;                                         // 0x0158(0x0008)(ZeroConstructor, Transient, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	class UAISystemBase*                          AISystem;                                          // 0x0160(0x0008)(ZeroConstructor, Transient, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	class UAvoidanceManager*                      AvoidanceManager;                                  // 0x0168(0x0008)(ZeroConstructor, Transient, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	TArray<class ULevel*>                         Levels;                                            // 0x0170(0x0010)(ZeroConstructor, Transient, UObjectWrapper, NativeAccessSpecifierPrivate)
	TArray<struct FLevelCollection>               LevelCollections;                                  // 0x0180(0x0010)(ZeroConstructor, Transient, NonTransactional, NativeAccessSpecifierPrivate)
	uint8                                         Pad_190[0x28];                                     // 0x0190(0x0028)(Fixing Size After Last Property [ Dumper-7 ])
	class UGameInstance*                          OwningGameInstance;                                // 0x01B8(0x0008)(ZeroConstructor, Transient, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	TArray<class UMaterialParameterCollectionInstance*> ParameterCollectionInstances;                // 0x01C0(0x0010)(ZeroConstructor, Transient, UObjectWrapper, NativeAccessSpecifierPrivate)
	class UCanvas*                                CanvasForRenderingToTarget;                        // 0x01D0(0x0008)(ZeroConstructor, Transient, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	class UCanvas*                                CanvasForDrawMaterialToRenderTarget;               // 0x01D8(0x0008)(ZeroConstructor, Transient, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_1E0[0x70];                                     // 0x01E0(0x0070)(Fixing Size After Last Property [ Dumper-7 ])
	class UPhysicsFieldComponent*                 PhysicsField;                                      // 0x0250(0x0008)(ExportObject, ZeroConstructor, Transient, InstancedReference, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint32                                        LWILastAssignedUID;                                // 0x0258(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_25C[0x4];                                      // 0x025C(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	TSet<class UActorComponent*>                  ComponentsThatNeedPreEndOfFrameSync;               // 0x0260(0x0050)(ExportObject, Transient, NonTransactional, ContainsInstancedReference, UObjectWrapper, NativeAccessSpecifierPrivate)
	TArray<class UActorComponent*>                ComponentsThatNeedEndOfFrameUpdate;                // 0x02B0(0x0010)(ExportObject, ZeroConstructor, Transient, NonTransactional, ContainsInstancedReference, UObjectWrapper, NativeAccessSpecifierPrivate)
	TArray<class UActorComponent*>                ComponentsThatNeedEndOfFrameUpdate_OnGameThread;   // 0x02C0(0x0010)(ExportObject, ZeroConstructor, Transient, NonTransactional, ContainsInstancedReference, UObjectWrapper, NativeAccessSpecifierPrivate)
	uint8                                         Pad_2D0[0x450];                                    // 0x02D0(0x0450)(Fixing Size After Last Property [ Dumper-7 ])
	class UWorldComposition*                      WorldComposition;                                  // 0x0720(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UContentBundleManager*                  ContentBundleManager;                              // 0x0728(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_730[0xB0];                                     // 0x0730(0x00B0)(Fixing Size After Last Property [ Dumper-7 ])
	struct FWorldPSCPool                          PSCPool;                                           // 0x07E0(0x0058)(ContainsInstancedReference, NativeAccessSpecifierPrivate)
	uint8                                         Pad_838[0xC0];                                     // 0x0838(0x00C0)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UWorld* GetWorld();

	void HandleTimelineScrubbed();
	class AWorldSettings* K2_GetWorldSettings();

	class UDataLayerManager* GetDataLayerManager() const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"World">();
	}
	static class UWorld* GetDefaultObj()
	{
		return GetDefaultObjImpl<UWorld>();
	}
};
static_assert(alignof(UWorld) == 0x000008, "Wrong alignment on UWorld");
static_assert(sizeof(UWorld) == 0x0008F8, "Wrong size on UWorld");
static_assert(offsetof(UWorld, PersistentLevel) == 0x000030, "Member 'UWorld::PersistentLevel' has a wrong offset!");
static_assert(offsetof(UWorld, NetDriver) == 0x000038, "Member 'UWorld::NetDriver' has a wrong offset!");
static_assert(offsetof(UWorld, LineBatcher) == 0x000040, "Member 'UWorld::LineBatcher' has a wrong offset!");
static_assert(offsetof(UWorld, PersistentLineBatcher) == 0x000048, "Member 'UWorld::PersistentLineBatcher' has a wrong offset!");
static_assert(offsetof(UWorld, ForegroundLineBatcher) == 0x000050, "Member 'UWorld::ForegroundLineBatcher' has a wrong offset!");
static_assert(offsetof(UWorld, NetworkManager) == 0x000058, "Member 'UWorld::NetworkManager' has a wrong offset!");
static_assert(offsetof(UWorld, PhysicsCollisionHandler) == 0x000060, "Member 'UWorld::PhysicsCollisionHandler' has a wrong offset!");
static_assert(offsetof(UWorld, ExtraReferencedObjects) == 0x000068, "Member 'UWorld::ExtraReferencedObjects' has a wrong offset!");
static_assert(offsetof(UWorld, PerModuleDataObjects) == 0x000078, "Member 'UWorld::PerModuleDataObjects' has a wrong offset!");
static_assert(offsetof(UWorld, StreamingLevels) == 0x000088, "Member 'UWorld::StreamingLevels' has a wrong offset!");
static_assert(offsetof(UWorld, StreamingLevelsToConsider) == 0x000098, "Member 'UWorld::StreamingLevelsToConsider' has a wrong offset!");
static_assert(offsetof(UWorld, ServerStreamingLevelsVisibility) == 0x0000C0, "Member 'UWorld::ServerStreamingLevelsVisibility' has a wrong offset!");
static_assert(offsetof(UWorld, StreamingLevelsPrefix) == 0x0000C8, "Member 'UWorld::StreamingLevelsPrefix' has a wrong offset!");
static_assert(offsetof(UWorld, CurrentLevelPendingVisibility) == 0x0000E0, "Member 'UWorld::CurrentLevelPendingVisibility' has a wrong offset!");
static_assert(offsetof(UWorld, CurrentLevelPendingInvisibility) == 0x0000E8, "Member 'UWorld::CurrentLevelPendingInvisibility' has a wrong offset!");
static_assert(offsetof(UWorld, DemoNetDriver) == 0x0000F0, "Member 'UWorld::DemoNetDriver' has a wrong offset!");
static_assert(offsetof(UWorld, MyParticleEventManager) == 0x0000F8, "Member 'UWorld::MyParticleEventManager' has a wrong offset!");
static_assert(offsetof(UWorld, DefaultPhysicsVolume) == 0x000100, "Member 'UWorld::DefaultPhysicsVolume' has a wrong offset!");
static_assert(offsetof(UWorld, NavigationSystem) == 0x000148, "Member 'UWorld::NavigationSystem' has a wrong offset!");
static_assert(offsetof(UWorld, AuthorityGameMode) == 0x000150, "Member 'UWorld::AuthorityGameMode' has a wrong offset!");
static_assert(offsetof(UWorld, GameState) == 0x000158, "Member 'UWorld::GameState' has a wrong offset!");
static_assert(offsetof(UWorld, AISystem) == 0x000160, "Member 'UWorld::AISystem' has a wrong offset!");
static_assert(offsetof(UWorld, AvoidanceManager) == 0x000168, "Member 'UWorld::AvoidanceManager' has a wrong offset!");
static_assert(offsetof(UWorld, Levels) == 0x000170, "Member 'UWorld::Levels' has a wrong offset!");
static_assert(offsetof(UWorld, LevelCollections) == 0x000180, "Member 'UWorld::LevelCollections' has a wrong offset!");
static_assert(offsetof(UWorld, OwningGameInstance) == 0x0001B8, "Member 'UWorld::OwningGameInstance' has a wrong offset!");
static_assert(offsetof(UWorld, ParameterCollectionInstances) == 0x0001C0, "Member 'UWorld::ParameterCollectionInstances' has a wrong offset!");
static_assert(offsetof(UWorld, CanvasForRenderingToTarget) == 0x0001D0, "Member 'UWorld::CanvasForRenderingToTarget' has a wrong offset!");
static_assert(offsetof(UWorld, CanvasForDrawMaterialToRenderTarget) == 0x0001D8, "Member 'UWorld::CanvasForDrawMaterialToRenderTarget' has a wrong offset!");
static_assert(offsetof(UWorld, PhysicsField) == 0x000250, "Member 'UWorld::PhysicsField' has a wrong offset!");
static_assert(offsetof(UWorld, LWILastAssignedUID) == 0x000258, "Member 'UWorld::LWILastAssignedUID' has a wrong offset!");
static_assert(offsetof(UWorld, ComponentsThatNeedPreEndOfFrameSync) == 0x000260, "Member 'UWorld::ComponentsThatNeedPreEndOfFrameSync' has a wrong offset!");
static_assert(offsetof(UWorld, ComponentsThatNeedEndOfFrameUpdate) == 0x0002B0, "Member 'UWorld::ComponentsThatNeedEndOfFrameUpdate' has a wrong offset!");
static_assert(offsetof(UWorld, ComponentsThatNeedEndOfFrameUpdate_OnGameThread) == 0x0002C0, "Member 'UWorld::ComponentsThatNeedEndOfFrameUpdate_OnGameThread' has a wrong offset!");
static_assert(offsetof(UWorld, WorldComposition) == 0x000720, "Member 'UWorld::WorldComposition' has a wrong offset!");
static_assert(offsetof(UWorld, ContentBundleManager) == 0x000728, "Member 'UWorld::ContentBundleManager' has a wrong offset!");
static_assert(offsetof(UWorld, PSCPool) == 0x0007E0, "Member 'UWorld::PSCPool' has a wrong offset!");

// Class Engine.LevelStreaming
// 0x0178 (0x01A0 - 0x0028)
#pragma pack(push, 0x1)
class alignas(0x10) ULevelStreaming : public UObject
{
public:
	TSoftObjectPtr<class UWorld>                  WorldAsset;                                        // 0x0028(0x0028)(Edit, BlueprintVisible, BlueprintReadOnly, EditConst, Protected, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	int32                                         StreamingPriority;                                 // 0x0050(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	class FName                                   PackageNameToLoad;                                 // 0x0054(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_5C[0x4];                                       // 0x005C(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<class FName>                           LODPackageNames;                                   // 0x0060(0x0010)(ZeroConstructor, NativeAccessSpecifierPublic)
	uint8                                         Pad_70[0x10];                                      // 0x0070(0x0010)(Fixing Size After Last Property [ Dumper-7 ])
	struct FTransform                             LevelTransform;                                    // 0x0080(0x0060)(Edit, BlueprintVisible, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bClientOnlyVisible;                                // 0x00E0(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_E1[0x3];                                       // 0x00E1(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	int32                                         LevelLODIndex;                                     // 0x00E4(0x0004)(BlueprintVisible, ZeroConstructor, Transient, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         BitPad_E8_0 : 3;                                   // 0x00E8(0x0001)(Fixing Bit-Field Size Between Bits [ Dumper-7 ])
	uint8                                         bShouldBeVisible : 1;                              // 0x00E8(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate))
	uint8                                         bShouldBeLoaded : 1;                               // 0x00E8(0x0001)(BitIndex: 0x04, PropSize: 0x0001 (BlueprintVisible, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
	uint8                                         BitPad_E8_5 : 3;                                   // 0x00E8(0x0001)(Fixing Bit-Field Size For New Byte [ Dumper-7 ])
	uint8                                         Pad_E9[0x2];                                       // 0x00E9(0x0002)(Fixing Size After Last Property [ Dumper-7 ])
	uint8                                         bLocked : 1;                                       // 0x00EB(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bIsStatic : 1;                                     // 0x00EB(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, DisableEditOnInstance, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bShouldBlockOnLoad : 1;                            // 0x00EB(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bShouldBlockOnUnload : 1;                          // 0x00EB(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bDisableDistanceStreaming : 1;                     // 0x00EB(0x0001)(BitIndex: 0x04, PropSize: 0x0001 (BlueprintVisible, Transient, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bDrawOnLevelStatusMap : 1;                         // 0x00EB(0x0001)(BitIndex: 0x05, PropSize: 0x0001 (Edit, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	struct FLinearColor                           LevelColor;                                        // 0x00EC(0x0010)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_FC[0x4];                                       // 0x00FC(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<class ALevelStreamingVolume*>          EditorStreamingVolumes;                            // 0x0100(0x0010)(Edit, ZeroConstructor, UObjectWrapper, NativeAccessSpecifierPublic)
	float                                         MinTimeBetweenVolumeUnloadRequests;                // 0x0110(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_114[0x4];                                      // 0x0114(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	TMulticastInlineDelegate<void()>              OnLevelLoaded;                                     // 0x0118(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	TMulticastInlineDelegate<void()>              OnLevelUnloaded;                                   // 0x0128(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	TMulticastInlineDelegate<void()>              OnLevelShown;                                      // 0x0138(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	TMulticastInlineDelegate<void()>              OnLevelHidden;                                     // 0x0148(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	class ULevel*                                 LoadedLevel;                                       // 0x0158(0x0008)(ZeroConstructor, Transient, NoDestructor, Protected, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	class ULevel*                                 PendingUnloadLevel;                                // 0x0160(0x0008)(ZeroConstructor, Transient, NoDestructor, Protected, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_168[0x30];                                     // 0x0168(0x0030)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	class ULevelStreaming* CreateInstance(const class FString& UniqueInstanceName);
	class ALevelScriptActor* GetLevelScriptActor();
	void SetIsRequestingUnloadAndRemoval(bool bInIsRequestingUnloadAndRemoval);
	void SetLevelLODIndex(int32 LODIndex);
	void SetPriority(int32 NewPriority);
	void SetShouldBeLoaded(bool bInShouldBeLoaded);
	void SetShouldBeVisible(bool bInShouldBeVisible);

	bool GetIsRequestingUnloadAndRemoval() const;
	class ULevel* GetLoadedLevel() const;
	class FName GetWorldAssetPackageFName() const;
	bool IsLevelLoaded() const;
	bool IsLevelVisible() const;
	bool IsStreamingStatePending() const;
	bool ShouldBeLoaded() const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"LevelStreaming">();
	}
	static class ULevelStreaming* GetDefaultObj()
	{
		return GetDefaultObjImpl<ULevelStreaming>();
	}
};
#pragma pack(pop)
static_assert(alignof(ULevelStreaming) == 0x000010, "Wrong alignment on ULevelStreaming");
static_assert(sizeof(ULevelStreaming) == 0x0001A0, "Wrong size on ULevelStreaming");
static_assert(offsetof(ULevelStreaming, WorldAsset) == 0x000028, "Member 'ULevelStreaming::WorldAsset' has a wrong offset!");
static_assert(offsetof(ULevelStreaming, StreamingPriority) == 0x000050, "Member 'ULevelStreaming::StreamingPriority' has a wrong offset!");
static_assert(offsetof(ULevelStreaming, PackageNameToLoad) == 0x000054, "Member 'ULevelStreaming::PackageNameToLoad' has a wrong offset!");
static_assert(offsetof(ULevelStreaming, LODPackageNames) == 0x000060, "Member 'ULevelStreaming::LODPackageNames' has a wrong offset!");
static_assert(offsetof(ULevelStreaming, LevelTransform) == 0x000080, "Member 'ULevelStreaming::LevelTransform' has a wrong offset!");
static_assert(offsetof(ULevelStreaming, bClientOnlyVisible) == 0x0000E0, "Member 'ULevelStreaming::bClientOnlyVisible' has a wrong offset!");
static_assert(offsetof(ULevelStreaming, LevelLODIndex) == 0x0000E4, "Member 'ULevelStreaming::LevelLODIndex' has a wrong offset!");
static_assert(offsetof(ULevelStreaming, LevelColor) == 0x0000EC, "Member 'ULevelStreaming::LevelColor' has a wrong offset!");
static_assert(offsetof(ULevelStreaming, EditorStreamingVolumes) == 0x000100, "Member 'ULevelStreaming::EditorStreamingVolumes' has a wrong offset!");
static_assert(offsetof(ULevelStreaming, MinTimeBetweenVolumeUnloadRequests) == 0x000110, "Member 'ULevelStreaming::MinTimeBetweenVolumeUnloadRequests' has a wrong offset!");
static_assert(offsetof(ULevelStreaming, OnLevelLoaded) == 0x000118, "Member 'ULevelStreaming::OnLevelLoaded' has a wrong offset!");
static_assert(offsetof(ULevelStreaming, OnLevelUnloaded) == 0x000128, "Member 'ULevelStreaming::OnLevelUnloaded' has a wrong offset!");
static_assert(offsetof(ULevelStreaming, OnLevelShown) == 0x000138, "Member 'ULevelStreaming::OnLevelShown' has a wrong offset!");
static_assert(offsetof(ULevelStreaming, OnLevelHidden) == 0x000148, "Member 'ULevelStreaming::OnLevelHidden' has a wrong offset!");
static_assert(offsetof(ULevelStreaming, LoadedLevel) == 0x000158, "Member 'ULevelStreaming::LoadedLevel' has a wrong offset!");
static_assert(offsetof(ULevelStreaming, PendingUnloadLevel) == 0x000160, "Member 'ULevelStreaming::PendingUnloadLevel' has a wrong offset!");

// Class Engine.MaterialExpressionGetMaterialAttributes
// 0x0040 (0x00F0 - 0x00B0)
class UMaterialExpressionGetMaterialAttributes final : public UMaterialExpression
{
public:
	struct FMaterialAttributesInput               MaterialAttributes;                                // 0x00B0(0x0030)(NoDestructor, NativeAccessSpecifierPublic)
	TArray<struct FGuid>                          AttributeGetTypes;                                 // 0x00E0(0x0010)(Edit, ZeroConstructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionGetMaterialAttributes">();
	}
	static class UMaterialExpressionGetMaterialAttributes* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionGetMaterialAttributes>();
	}
};
static_assert(alignof(UMaterialExpressionGetMaterialAttributes) == 0x000008, "Wrong alignment on UMaterialExpressionGetMaterialAttributes");
static_assert(sizeof(UMaterialExpressionGetMaterialAttributes) == 0x0000F0, "Wrong size on UMaterialExpressionGetMaterialAttributes");
static_assert(offsetof(UMaterialExpressionGetMaterialAttributes, MaterialAttributes) == 0x0000B0, "Member 'UMaterialExpressionGetMaterialAttributes::MaterialAttributes' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionGetMaterialAttributes, AttributeGetTypes) == 0x0000E0, "Member 'UMaterialExpressionGetMaterialAttributes::AttributeGetTypes' has a wrong offset!");

// Class Engine.ParticleModuleKillBox
// 0x00C8 (0x00F8 - 0x0030)
class UParticleModuleKillBox final : public UParticleModuleKillBase
{
public:
	struct FRawDistributionVector                 LowerLeftCorner;                                   // 0x0030(0x0060)(Edit, ContainsInstancedReference, NativeAccessSpecifierPublic)
	struct FRawDistributionVector                 UpperRightCorner;                                  // 0x0090(0x0060)(Edit, ContainsInstancedReference, NativeAccessSpecifierPublic)
	uint8                                         bAbsolute : 1;                                     // 0x00F0(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bKillInside : 1;                                   // 0x00F0(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bAxisAlignedAndFixedSize : 1;                      // 0x00F0(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_F1[0x7];                                       // 0x00F1(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ParticleModuleKillBox">();
	}
	static class UParticleModuleKillBox* GetDefaultObj()
	{
		return GetDefaultObjImpl<UParticleModuleKillBox>();
	}
};
static_assert(alignof(UParticleModuleKillBox) == 0x000008, "Wrong alignment on UParticleModuleKillBox");
static_assert(sizeof(UParticleModuleKillBox) == 0x0000F8, "Wrong size on UParticleModuleKillBox");
static_assert(offsetof(UParticleModuleKillBox, LowerLeftCorner) == 0x000030, "Member 'UParticleModuleKillBox::LowerLeftCorner' has a wrong offset!");
static_assert(offsetof(UParticleModuleKillBox, UpperRightCorner) == 0x000090, "Member 'UParticleModuleKillBox::UpperRightCorner' has a wrong offset!");

// Class Engine.LevelStreamingAlwaysLoaded
// 0x0000 (0x01A0 - 0x01A0)
class ULevelStreamingAlwaysLoaded : public ULevelStreaming
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"LevelStreamingAlwaysLoaded">();
	}
	static class ULevelStreamingAlwaysLoaded* GetDefaultObj()
	{
		return GetDefaultObjImpl<ULevelStreamingAlwaysLoaded>();
	}
};
static_assert(alignof(ULevelStreamingAlwaysLoaded) == 0x000010, "Wrong alignment on ULevelStreamingAlwaysLoaded");
static_assert(sizeof(ULevelStreamingAlwaysLoaded) == 0x0001A0, "Wrong size on ULevelStreamingAlwaysLoaded");

// Class Engine.DebugCameraHUD
// 0x0000 (0x0390 - 0x0390)
class ADebugCameraHUD final : public AHUD
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"DebugCameraHUD">();
	}
	static class ADebugCameraHUD* GetDefaultObj()
	{
		return GetDefaultObjImpl<ADebugCameraHUD>();
	}
};
static_assert(alignof(ADebugCameraHUD) == 0x000008, "Wrong alignment on ADebugCameraHUD");
static_assert(sizeof(ADebugCameraHUD) == 0x000390, "Wrong size on ADebugCameraHUD");

// Class Engine.HLODBuilderSettings
// 0x0000 (0x0028 - 0x0028)
class UHLODBuilderSettings final : public UObject
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"HLODBuilderSettings">();
	}
	static class UHLODBuilderSettings* GetDefaultObj()
	{
		return GetDefaultObjImpl<UHLODBuilderSettings>();
	}
};
static_assert(alignof(UHLODBuilderSettings) == 0x000008, "Wrong alignment on UHLODBuilderSettings");
static_assert(sizeof(UHLODBuilderSettings) == 0x000028, "Wrong size on UHLODBuilderSettings");

// Class Engine.MaterialExpressionIfThenElse
// 0x0038 (0x00E8 - 0x00B0)
class UMaterialExpressionIfThenElse final : public UMaterialExpression
{
public:
	struct FExpressionExecOutput                  Then;                                              // 0x00B0(0x0008)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionExecOutput                  Else;                                              // 0x00B8(0x0008)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       Condition;                                         // 0x00C0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionIfThenElse">();
	}
	static class UMaterialExpressionIfThenElse* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionIfThenElse>();
	}
};
static_assert(alignof(UMaterialExpressionIfThenElse) == 0x000008, "Wrong alignment on UMaterialExpressionIfThenElse");
static_assert(sizeof(UMaterialExpressionIfThenElse) == 0x0000E8, "Wrong size on UMaterialExpressionIfThenElse");
static_assert(offsetof(UMaterialExpressionIfThenElse, Then) == 0x0000B0, "Member 'UMaterialExpressionIfThenElse::Then' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionIfThenElse, Else) == 0x0000B8, "Member 'UMaterialExpressionIfThenElse::Else' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionIfThenElse, Condition) == 0x0000C0, "Member 'UMaterialExpressionIfThenElse::Condition' has a wrong offset!");

// Class Engine.LevelStreamingDynamic
// 0x0000 (0x01A0 - 0x01A0)
class ULevelStreamingDynamic : public ULevelStreaming
{
public:
	uint8                                         bInitiallyLoaded : 1;                              // 0x0198(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bInitiallyVisible : 1;                             // 0x0198(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_199[0x7];                                      // 0x0199(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class ULevelStreamingDynamic* LoadLevelInstance(class UObject* WorldContextObject, const class FString& LevelName, const struct FVector& Location, const struct FRotator& Rotation, bool* bOutSuccess, const class FString& OptionalLevelNameOverride, TSubclassOf<class ULevelStreamingDynamic> OptionalLevelStreamingClass, bool bLoadAsTempPackage);
	static class ULevelStreamingDynamic* LoadLevelInstanceBySoftObjectPtr(class UObject* WorldContextObject, TSoftObjectPtr<class UWorld> Level, const struct FVector& Location, const struct FRotator& Rotation, bool* bOutSuccess, const class FString& OptionalLevelNameOverride, TSubclassOf<class ULevelStreamingDynamic> OptionalLevelStreamingClass, bool bLoadAsTempPackage);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"LevelStreamingDynamic">();
	}
	static class ULevelStreamingDynamic* GetDefaultObj()
	{
		return GetDefaultObjImpl<ULevelStreamingDynamic>();
	}
};
static_assert(alignof(ULevelStreamingDynamic) == 0x000010, "Wrong alignment on ULevelStreamingDynamic");
static_assert(sizeof(ULevelStreamingDynamic) == 0x0001A0, "Wrong size on ULevelStreamingDynamic");

// Class Engine.LevelStreamingPersistent
// 0x0000 (0x01A0 - 0x01A0)
class ULevelStreamingPersistent final : public ULevelStreaming
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"LevelStreamingPersistent">();
	}
	static class ULevelStreamingPersistent* GetDefaultObj()
	{
		return GetDefaultObjImpl<ULevelStreamingPersistent>();
	}
};
static_assert(alignof(ULevelStreamingPersistent) == 0x000010, "Wrong alignment on ULevelStreamingPersistent");
static_assert(sizeof(ULevelStreamingPersistent) == 0x0001A0, "Wrong size on ULevelStreamingPersistent");

// Class Engine.LightComponentBase
// 0x0040 (0x02E0 - 0x02A0)
#pragma pack(push, 0x1)
class alignas(0x10) ULightComponentBase : public USceneComponent
{
public:
	struct FGuid                                  LightGuid;                                         // 0x02A0(0x0010)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         Brightness;                                        // 0x02B0(0x0004)(ZeroConstructor, Deprecated, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         Intensity;                                         // 0x02B4(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FColor                                 LightColor;                                        // 0x02B8(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bAffectsWorld : 1;                                 // 0x02BC(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         CastShadows : 1;                                   // 0x02BC(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         CastStaticShadows : 1;                             // 0x02BC(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         CastDynamicShadows : 1;                            // 0x02BC(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bAffectTranslucentLighting : 1;                    // 0x02BC(0x0001)(BitIndex: 0x04, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bTransmission : 1;                                 // 0x02BC(0x0001)(BitIndex: 0x05, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bCastVolumetricShadow : 1;                         // 0x02BC(0x0001)(BitIndex: 0x06, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bCastDeepShadow : 1;                               // 0x02BC(0x0001)(BitIndex: 0x07, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bCastRaytracedShadow : 1;                          // 0x02BD(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Deprecated, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_2BE[0x2];                                      // 0x02BE(0x0002)(Fixing Size After Last Property [ Dumper-7 ])
	ECastRayTracedShadow                          CastRaytracedShadow;                               // 0x02C0(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_2C1[0x3];                                      // 0x02C1(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	uint8                                         bAffectReflection : 1;                             // 0x02C4(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bAffectGlobalIllumination : 1;                     // 0x02C4(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_2C5[0x3];                                      // 0x02C5(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         DeepShadowLayerDistribution;                       // 0x02C8(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         IndirectLightingIntensity;                         // 0x02CC(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         VolumetricScatteringIntensity;                     // 0x02D0(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         SamplesPerPixel;                                   // 0x02D4(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

public:
	void SetAffectGlobalIllumination(bool bNewValue);
	void SetAffectReflection(bool bNewValue);
	void SetCastDeepShadow(bool bNewValue);
	void SetCastRaytracedShadow(bool bNewValue);
	void SetCastRaytracedShadows(ECastRayTracedShadow bNewValue);
	void SetCastShadows(bool bNewValue);
	void SetCastVolumetricShadow(bool bNewValue);
	void SetSamplesPerPixel(int32 NewValue);

	struct FLinearColor GetLightColor() const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"LightComponentBase">();
	}
	static class ULightComponentBase* GetDefaultObj()
	{
		return GetDefaultObjImpl<ULightComponentBase>();
	}
};
#pragma pack(pop)
static_assert(alignof(ULightComponentBase) == 0x000010, "Wrong alignment on ULightComponentBase");
static_assert(sizeof(ULightComponentBase) == 0x0002E0, "Wrong size on ULightComponentBase");
static_assert(offsetof(ULightComponentBase, LightGuid) == 0x0002A0, "Member 'ULightComponentBase::LightGuid' has a wrong offset!");
static_assert(offsetof(ULightComponentBase, Brightness) == 0x0002B0, "Member 'ULightComponentBase::Brightness' has a wrong offset!");
static_assert(offsetof(ULightComponentBase, Intensity) == 0x0002B4, "Member 'ULightComponentBase::Intensity' has a wrong offset!");
static_assert(offsetof(ULightComponentBase, LightColor) == 0x0002B8, "Member 'ULightComponentBase::LightColor' has a wrong offset!");
static_assert(offsetof(ULightComponentBase, CastRaytracedShadow) == 0x0002C0, "Member 'ULightComponentBase::CastRaytracedShadow' has a wrong offset!");
static_assert(offsetof(ULightComponentBase, DeepShadowLayerDistribution) == 0x0002C8, "Member 'ULightComponentBase::DeepShadowLayerDistribution' has a wrong offset!");
static_assert(offsetof(ULightComponentBase, IndirectLightingIntensity) == 0x0002CC, "Member 'ULightComponentBase::IndirectLightingIntensity' has a wrong offset!");
static_assert(offsetof(ULightComponentBase, VolumetricScatteringIntensity) == 0x0002D0, "Member 'ULightComponentBase::VolumetricScatteringIntensity' has a wrong offset!");
static_assert(offsetof(ULightComponentBase, SamplesPerPixel) == 0x0002D4, "Member 'ULightComponentBase::SamplesPerPixel' has a wrong offset!");

// Class Engine.LightComponent
// 0x0110 (0x03F0 - 0x02E0)
class ULightComponent : public ULightComponentBase
{
public:
	float                                         Temperature;                                       // 0x02D8(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         MaxDrawDistance;                                   // 0x02DC(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         MaxDistanceFadeRange;                              // 0x02E0(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bUseTemperature : 1;                               // 0x02E4(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_2E5[0x3];                                      // 0x02E5(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	int32                                         ShadowMapChannel;                                  // 0x02E8(0x0004)(ZeroConstructor, Deprecated, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_2EC[0x4];                                      // 0x02EC(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         MinRoughness;                                      // 0x02F0(0x0004)(ZeroConstructor, Deprecated, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         SpecularScale;                                     // 0x02F4(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         ShadowResolutionScale;                             // 0x02F8(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         ShadowBias;                                        // 0x02FC(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         ShadowSlopeBias;                                   // 0x0300(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         ShadowSharpen;                                     // 0x0304(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         ContactShadowLength;                               // 0x0308(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         ContactShadowLengthInWS : 1;                       // 0x030C(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_30D[0x3];                                      // 0x030D(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         ContactShadowCastingIntensity;                     // 0x0310(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         ContactShadowNonCastingIntensity;                  // 0x0314(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         VSMProjectResolutionBias;                          // 0x0318(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         InverseSquaredFalloff : 1;                         // 0x031C(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Deprecated, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         CastTranslucentShadows : 1;                        // 0x031C(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bCastShadowsFromCinematicObjectsOnly : 1;          // 0x031C(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bForceCachedShadowsForMovablePrimitives : 1;       // 0x031C(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_31D[0x3];                                      // 0x031D(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	struct FLightingChannels                      LightingChannels;                                  // 0x0320(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, AdvancedDisplay, NativeAccessSpecifierPublic)
	uint8                                         Pad_321[0x7];                                      // 0x0321(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	class UMaterialInterface*                     LightFunctionMaterial;                             // 0x0328(0x0008)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector                                LightFunctionScale;                                // 0x0330(0x0018)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UTextureLightProfile*                   IESTexture;                                        // 0x0348(0x0008)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bUseIESBrightness : 1;                             // 0x0350(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_351[0x3];                                      // 0x0351(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         IESBrightnessScale;                                // 0x0354(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         LightFunctionFadeDistance;                         // 0x0358(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         DisabledBrightness;                                // 0x035C(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bEnableLightShaftBloom : 1;                        // 0x0360(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_361[0x3];                                      // 0x0361(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         BloomScale;                                        // 0x0364(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         BloomThreshold;                                    // 0x0368(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         BloomMaxBrightness;                                // 0x036C(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FColor                                 BloomTint;                                         // 0x0370(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bUseRayTracedDistanceFieldShadows;                 // 0x0374(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_375[0x3];                                      // 0x0375(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         RayStartOffsetDepthScale;                          // 0x0378(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_37C[0x74];                                     // 0x037C(0x0074)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void SetAffectTranslucentLighting(bool bNewValue);
	void SetBloomMaxBrightness(float NewValue);
	void SetBloomScale(float NewValue);
	void SetBloomThreshold(float NewValue);
	void SetBloomTint(const struct FColor& NewValue);
	void SetEnableLightShaftBloom(bool bNewValue);
	void SetForceCachedShadowsForMovablePrimitives(bool bNewValue);
	void SetIESBrightnessScale(float NewValue);
	void SetIESTexture(class UTextureLightProfile* NewValue);
	void SetIndirectLightingIntensity(float NewIntensity);
	void SetIntensity(float NewIntensity);
	void SetLightColor(const struct FLinearColor& NewLightColor, bool bSRGB);
	void SetLightFColor(const struct FColor& NewLightColor);
	void SetLightFunctionDisabledBrightness(float NewValue);
	void SetLightFunctionFadeDistance(float NewLightFunctionFadeDistance);
	void SetLightFunctionMaterial(class UMaterialInterface* NewLightFunctionMaterial);
	void SetLightFunctionScale(const struct FVector& NewLightFunctionScale);
	void SetLightingChannels(bool bChannel0, bool bChannel1, bool bChannel2);
	void SetShadowBias(float NewValue);
	void SetShadowSlopeBias(float NewValue);
	void SetSpecularScale(float NewValue);
	void SetTemperature(float NewTemperature);
	void SetTransmission(bool bNewValue);
	void SetUseIESBrightness(bool bNewValue);
	void SetUseTemperature(bool bNewValue);
	void SetVolumetricScatteringIntensity(float NewIntensity);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"LightComponent">();
	}
	static class ULightComponent* GetDefaultObj()
	{
		return GetDefaultObjImpl<ULightComponent>();
	}
};
static_assert(alignof(ULightComponent) == 0x000010, "Wrong alignment on ULightComponent");
static_assert(sizeof(ULightComponent) == 0x0003F0, "Wrong size on ULightComponent");
static_assert(offsetof(ULightComponent, Temperature) == 0x0002D8, "Member 'ULightComponent::Temperature' has a wrong offset!");
static_assert(offsetof(ULightComponent, MaxDrawDistance) == 0x0002DC, "Member 'ULightComponent::MaxDrawDistance' has a wrong offset!");
static_assert(offsetof(ULightComponent, MaxDistanceFadeRange) == 0x0002E0, "Member 'ULightComponent::MaxDistanceFadeRange' has a wrong offset!");
static_assert(offsetof(ULightComponent, ShadowMapChannel) == 0x0002E8, "Member 'ULightComponent::ShadowMapChannel' has a wrong offset!");
static_assert(offsetof(ULightComponent, MinRoughness) == 0x0002F0, "Member 'ULightComponent::MinRoughness' has a wrong offset!");
static_assert(offsetof(ULightComponent, SpecularScale) == 0x0002F4, "Member 'ULightComponent::SpecularScale' has a wrong offset!");
static_assert(offsetof(ULightComponent, ShadowResolutionScale) == 0x0002F8, "Member 'ULightComponent::ShadowResolutionScale' has a wrong offset!");
static_assert(offsetof(ULightComponent, ShadowBias) == 0x0002FC, "Member 'ULightComponent::ShadowBias' has a wrong offset!");
static_assert(offsetof(ULightComponent, ShadowSlopeBias) == 0x000300, "Member 'ULightComponent::ShadowSlopeBias' has a wrong offset!");
static_assert(offsetof(ULightComponent, ShadowSharpen) == 0x000304, "Member 'ULightComponent::ShadowSharpen' has a wrong offset!");
static_assert(offsetof(ULightComponent, ContactShadowLength) == 0x000308, "Member 'ULightComponent::ContactShadowLength' has a wrong offset!");
static_assert(offsetof(ULightComponent, ContactShadowCastingIntensity) == 0x000310, "Member 'ULightComponent::ContactShadowCastingIntensity' has a wrong offset!");
static_assert(offsetof(ULightComponent, ContactShadowNonCastingIntensity) == 0x000314, "Member 'ULightComponent::ContactShadowNonCastingIntensity' has a wrong offset!");
static_assert(offsetof(ULightComponent, VSMProjectResolutionBias) == 0x000318, "Member 'ULightComponent::VSMProjectResolutionBias' has a wrong offset!");
static_assert(offsetof(ULightComponent, LightingChannels) == 0x000320, "Member 'ULightComponent::LightingChannels' has a wrong offset!");
static_assert(offsetof(ULightComponent, LightFunctionMaterial) == 0x000328, "Member 'ULightComponent::LightFunctionMaterial' has a wrong offset!");
static_assert(offsetof(ULightComponent, LightFunctionScale) == 0x000330, "Member 'ULightComponent::LightFunctionScale' has a wrong offset!");
static_assert(offsetof(ULightComponent, IESTexture) == 0x000348, "Member 'ULightComponent::IESTexture' has a wrong offset!");
static_assert(offsetof(ULightComponent, IESBrightnessScale) == 0x000354, "Member 'ULightComponent::IESBrightnessScale' has a wrong offset!");
static_assert(offsetof(ULightComponent, LightFunctionFadeDistance) == 0x000358, "Member 'ULightComponent::LightFunctionFadeDistance' has a wrong offset!");
static_assert(offsetof(ULightComponent, DisabledBrightness) == 0x00035C, "Member 'ULightComponent::DisabledBrightness' has a wrong offset!");
static_assert(offsetof(ULightComponent, BloomScale) == 0x000364, "Member 'ULightComponent::BloomScale' has a wrong offset!");
static_assert(offsetof(ULightComponent, BloomThreshold) == 0x000368, "Member 'ULightComponent::BloomThreshold' has a wrong offset!");
static_assert(offsetof(ULightComponent, BloomMaxBrightness) == 0x00036C, "Member 'ULightComponent::BloomMaxBrightness' has a wrong offset!");
static_assert(offsetof(ULightComponent, BloomTint) == 0x000370, "Member 'ULightComponent::BloomTint' has a wrong offset!");
static_assert(offsetof(ULightComponent, bUseRayTracedDistanceFieldShadows) == 0x000374, "Member 'ULightComponent::bUseRayTracedDistanceFieldShadows' has a wrong offset!");
static_assert(offsetof(ULightComponent, RayStartOffsetDepthScale) == 0x000378, "Member 'ULightComponent::RayStartOffsetDepthScale' has a wrong offset!");

// Class Engine.DirectionalLightComponent
// 0x00D0 (0x04C0 - 0x03F0)
class UDirectionalLightComponent final : public ULightComponent
{
public:
	float                                         ShadowCascadeBiasDistribution;                     // 0x03F0(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bEnableLightShaftOcclusion : 1;                    // 0x03F4(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_3F5[0x3];                                      // 0x03F5(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         OcclusionMaskDarkness;                             // 0x03F8(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         OcclusionDepthRange;                               // 0x03FC(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector                                LightShaftOverrideDirection;                       // 0x0400(0x0018)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         WholeSceneDynamicShadowRadius;                     // 0x0418(0x0004)(ZeroConstructor, Deprecated, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         DynamicShadowDistanceMovableLight;                 // 0x041C(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         DynamicShadowDistanceStationaryLight;              // 0x0420(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         DynamicShadowCascades;                             // 0x0424(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         CascadeDistributionExponent;                       // 0x0428(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         CascadeTransitionFraction;                         // 0x042C(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         ShadowDistanceFadeoutFraction;                     // 0x0430(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bUseInsetShadowsForMovableObjects : 1;             // 0x0434(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_435[0x3];                                      // 0x0435(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	int32                                         FarShadowCascadeCount;                             // 0x0438(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         FarShadowDistance;                                 // 0x043C(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         DistanceFieldShadowDistance;                       // 0x0440(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         ForwardShadingPriority;                            // 0x0444(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         LightSourceAngle;                                  // 0x0448(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         LightSourceSoftAngle;                              // 0x044C(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         ShadowSourceAngleFactor;                           // 0x0450(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         TraceDistance;                                     // 0x0454(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bUsedAsAtmosphereSunLight : 1;                     // 0x0458(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Deprecated, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bAtmosphereSunLight : 1;                           // 0x0458(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_459[0x3];                                      // 0x0459(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	int32                                         AtmosphereSunLightIndex;                           // 0x045C(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FLinearColor                           AtmosphereSunDiskColorScale;                       // 0x0460(0x0010)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bPerPixelAtmosphereTransmittance : 1;              // 0x0470(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bCastShadowsOnClouds : 1;                          // 0x0470(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bCastShadowsOnAtmosphere : 1;                      // 0x0470(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bCastCloudShadows : 1;                             // 0x0470(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_471[0x3];                                      // 0x0471(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         CloudShadowStrength;                               // 0x0474(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         CloudShadowOnAtmosphereStrength;                   // 0x0478(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         CloudShadowOnSurfaceStrength;                      // 0x047C(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         CloudShadowDepthBias;                              // 0x0480(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         CloudShadowExtent;                                 // 0x0484(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         CloudShadowMapResolutionScale;                     // 0x0488(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         CloudShadowRaySampleCountScale;                    // 0x048C(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FLinearColor                           CloudScatteredLuminanceScale;                      // 0x0490(0x0010)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FLightmassDirectionalLightSettings     LightmassSettings;                                 // 0x04A0(0x0010)(Edit, NoDestructor, NativeAccessSpecifierPublic)
	uint8                                         bCastModulatedShadows : 1;                         // 0x04B0(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_4B1[0x3];                                      // 0x04B1(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	struct FColor                                 ModulatedShadowColor;                              // 0x04B4(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         ShadowAmount;                                      // 0x04B8(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_4BC[0x4];                                      // 0x04BC(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void SetAtmosphereSunLight(bool bNewValue);
	void SetAtmosphereSunLightIndex(int32 NewValue);
	void SetCascadeDistributionExponent(float NewValue);
	void SetCascadeTransitionFraction(float NewValue);
	void SetDynamicShadowCascades(int32 NewValue);
	void SetDynamicShadowDistanceMovableLight(float NewValue);
	void SetDynamicShadowDistanceStationaryLight(float NewValue);
	void SetEnableLightShaftOcclusion(bool bNewValue);
	void SetForwardShadingPriority(int32 NewValue);
	void SetLightShaftOverrideDirection(const struct FVector& NewValue);
	void SetLightSourceAngle(float NewValue);
	void SetLightSourceSoftAngle(float NewValue);
	void SetOcclusionDepthRange(float NewValue);
	void SetOcclusionMaskDarkness(float NewValue);
	void SetShadowAmount(float NewValue);
	void SetShadowCascadeBiasDistribution(float NewValue);
	void SetShadowDistanceFadeoutFraction(float NewValue);
	void SetShadowSourceAngleFactor(float NewValue);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"DirectionalLightComponent">();
	}
	static class UDirectionalLightComponent* GetDefaultObj()
	{
		return GetDefaultObjImpl<UDirectionalLightComponent>();
	}
};
static_assert(alignof(UDirectionalLightComponent) == 0x000010, "Wrong alignment on UDirectionalLightComponent");
static_assert(sizeof(UDirectionalLightComponent) == 0x0004C0, "Wrong size on UDirectionalLightComponent");
static_assert(offsetof(UDirectionalLightComponent, ShadowCascadeBiasDistribution) == 0x0003F0, "Member 'UDirectionalLightComponent::ShadowCascadeBiasDistribution' has a wrong offset!");
static_assert(offsetof(UDirectionalLightComponent, OcclusionMaskDarkness) == 0x0003F8, "Member 'UDirectionalLightComponent::OcclusionMaskDarkness' has a wrong offset!");
static_assert(offsetof(UDirectionalLightComponent, OcclusionDepthRange) == 0x0003FC, "Member 'UDirectionalLightComponent::OcclusionDepthRange' has a wrong offset!");
static_assert(offsetof(UDirectionalLightComponent, LightShaftOverrideDirection) == 0x000400, "Member 'UDirectionalLightComponent::LightShaftOverrideDirection' has a wrong offset!");
static_assert(offsetof(UDirectionalLightComponent, WholeSceneDynamicShadowRadius) == 0x000418, "Member 'UDirectionalLightComponent::WholeSceneDynamicShadowRadius' has a wrong offset!");
static_assert(offsetof(UDirectionalLightComponent, DynamicShadowDistanceMovableLight) == 0x00041C, "Member 'UDirectionalLightComponent::DynamicShadowDistanceMovableLight' has a wrong offset!");
static_assert(offsetof(UDirectionalLightComponent, DynamicShadowDistanceStationaryLight) == 0x000420, "Member 'UDirectionalLightComponent::DynamicShadowDistanceStationaryLight' has a wrong offset!");
static_assert(offsetof(UDirectionalLightComponent, DynamicShadowCascades) == 0x000424, "Member 'UDirectionalLightComponent::DynamicShadowCascades' has a wrong offset!");
static_assert(offsetof(UDirectionalLightComponent, CascadeDistributionExponent) == 0x000428, "Member 'UDirectionalLightComponent::CascadeDistributionExponent' has a wrong offset!");
static_assert(offsetof(UDirectionalLightComponent, CascadeTransitionFraction) == 0x00042C, "Member 'UDirectionalLightComponent::CascadeTransitionFraction' has a wrong offset!");
static_assert(offsetof(UDirectionalLightComponent, ShadowDistanceFadeoutFraction) == 0x000430, "Member 'UDirectionalLightComponent::ShadowDistanceFadeoutFraction' has a wrong offset!");
static_assert(offsetof(UDirectionalLightComponent, FarShadowCascadeCount) == 0x000438, "Member 'UDirectionalLightComponent::FarShadowCascadeCount' has a wrong offset!");
static_assert(offsetof(UDirectionalLightComponent, FarShadowDistance) == 0x00043C, "Member 'UDirectionalLightComponent::FarShadowDistance' has a wrong offset!");
static_assert(offsetof(UDirectionalLightComponent, DistanceFieldShadowDistance) == 0x000440, "Member 'UDirectionalLightComponent::DistanceFieldShadowDistance' has a wrong offset!");
static_assert(offsetof(UDirectionalLightComponent, ForwardShadingPriority) == 0x000444, "Member 'UDirectionalLightComponent::ForwardShadingPriority' has a wrong offset!");
static_assert(offsetof(UDirectionalLightComponent, LightSourceAngle) == 0x000448, "Member 'UDirectionalLightComponent::LightSourceAngle' has a wrong offset!");
static_assert(offsetof(UDirectionalLightComponent, LightSourceSoftAngle) == 0x00044C, "Member 'UDirectionalLightComponent::LightSourceSoftAngle' has a wrong offset!");
static_assert(offsetof(UDirectionalLightComponent, ShadowSourceAngleFactor) == 0x000450, "Member 'UDirectionalLightComponent::ShadowSourceAngleFactor' has a wrong offset!");
static_assert(offsetof(UDirectionalLightComponent, TraceDistance) == 0x000454, "Member 'UDirectionalLightComponent::TraceDistance' has a wrong offset!");
static_assert(offsetof(UDirectionalLightComponent, AtmosphereSunLightIndex) == 0x00045C, "Member 'UDirectionalLightComponent::AtmosphereSunLightIndex' has a wrong offset!");
static_assert(offsetof(UDirectionalLightComponent, AtmosphereSunDiskColorScale) == 0x000460, "Member 'UDirectionalLightComponent::AtmosphereSunDiskColorScale' has a wrong offset!");
static_assert(offsetof(UDirectionalLightComponent, CloudShadowStrength) == 0x000474, "Member 'UDirectionalLightComponent::CloudShadowStrength' has a wrong offset!");
static_assert(offsetof(UDirectionalLightComponent, CloudShadowOnAtmosphereStrength) == 0x000478, "Member 'UDirectionalLightComponent::CloudShadowOnAtmosphereStrength' has a wrong offset!");
static_assert(offsetof(UDirectionalLightComponent, CloudShadowOnSurfaceStrength) == 0x00047C, "Member 'UDirectionalLightComponent::CloudShadowOnSurfaceStrength' has a wrong offset!");
static_assert(offsetof(UDirectionalLightComponent, CloudShadowDepthBias) == 0x000480, "Member 'UDirectionalLightComponent::CloudShadowDepthBias' has a wrong offset!");
static_assert(offsetof(UDirectionalLightComponent, CloudShadowExtent) == 0x000484, "Member 'UDirectionalLightComponent::CloudShadowExtent' has a wrong offset!");
static_assert(offsetof(UDirectionalLightComponent, CloudShadowMapResolutionScale) == 0x000488, "Member 'UDirectionalLightComponent::CloudShadowMapResolutionScale' has a wrong offset!");
static_assert(offsetof(UDirectionalLightComponent, CloudShadowRaySampleCountScale) == 0x00048C, "Member 'UDirectionalLightComponent::CloudShadowRaySampleCountScale' has a wrong offset!");
static_assert(offsetof(UDirectionalLightComponent, CloudScatteredLuminanceScale) == 0x000490, "Member 'UDirectionalLightComponent::CloudScatteredLuminanceScale' has a wrong offset!");
static_assert(offsetof(UDirectionalLightComponent, LightmassSettings) == 0x0004A0, "Member 'UDirectionalLightComponent::LightmassSettings' has a wrong offset!");
static_assert(offsetof(UDirectionalLightComponent, ModulatedShadowColor) == 0x0004B4, "Member 'UDirectionalLightComponent::ModulatedShadowColor' has a wrong offset!");
static_assert(offsetof(UDirectionalLightComponent, ShadowAmount) == 0x0004B8, "Member 'UDirectionalLightComponent::ShadowAmount' has a wrong offset!");

// Class Engine.MaterialExpressionParticlePositionWS
// 0x0008 (0x00B8 - 0x00B0)
class UMaterialExpressionParticlePositionWS final : public UMaterialExpression
{
public:
	EPositionOrigin                               OriginType;                                        // 0x00B0(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_B1[0x7];                                       // 0x00B1(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionParticlePositionWS">();
	}
	static class UMaterialExpressionParticlePositionWS* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionParticlePositionWS>();
	}
};
static_assert(alignof(UMaterialExpressionParticlePositionWS) == 0x000008, "Wrong alignment on UMaterialExpressionParticlePositionWS");
static_assert(sizeof(UMaterialExpressionParticlePositionWS) == 0x0000B8, "Wrong size on UMaterialExpressionParticlePositionWS");
static_assert(offsetof(UMaterialExpressionParticlePositionWS, OriginType) == 0x0000B0, "Member 'UMaterialExpressionParticlePositionWS::OriginType' has a wrong offset!");

// Class Engine.LevelStreamingVolume
// 0x0018 (0x02F0 - 0x02D8)
class ALevelStreamingVolume final : public AVolume
{
public:
	TArray<class FName>                           StreamingLevelNames;                               // 0x02D8(0x0010)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, EditConst, NativeAccessSpecifierPublic)
	uint8                                         bEditorPreVisOnly : 1;                             // 0x02E8(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bDisabled : 1;                                     // 0x02E8(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_2E9[0x3];                                      // 0x02E9(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	EStreamingVolumeUsage                         StreamingUsage;                                    // 0x02EC(0x0001)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_2ED[0x3];                                      // 0x02ED(0x0003)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"LevelStreamingVolume">();
	}
	static class ALevelStreamingVolume* GetDefaultObj()
	{
		return GetDefaultObjImpl<ALevelStreamingVolume>();
	}
};
static_assert(alignof(ALevelStreamingVolume) == 0x000008, "Wrong alignment on ALevelStreamingVolume");
static_assert(sizeof(ALevelStreamingVolume) == 0x0002F0, "Wrong size on ALevelStreamingVolume");
static_assert(offsetof(ALevelStreamingVolume, StreamingLevelNames) == 0x0002D8, "Member 'ALevelStreamingVolume::StreamingLevelNames' has a wrong offset!");
static_assert(offsetof(ALevelStreamingVolume, StreamingUsage) == 0x0002EC, "Member 'ALevelStreamingVolume::StreamingUsage' has a wrong offset!");

// Class Engine.AnimCompress_RemoveLinearKeys
// 0x0020 (0x0060 - 0x0040)
class UAnimCompress_RemoveLinearKeys : public UAnimCompress
{
public:
	float                                         MaxPosDiff;                                        // 0x0040(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         MaxAngleDiff;                                      // 0x0044(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         MaxScaleDiff;                                      // 0x0048(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         MaxEffectorDiff;                                   // 0x004C(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         MinEffectorDiff;                                   // 0x0050(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         EffectorDiffSocket;                                // 0x0054(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         ParentKeyScale;                                    // 0x0058(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bRetarget : 1;                                     // 0x005C(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bActuallyFilterLinearKeys : 1;                     // 0x005C(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_5D[0x3];                                       // 0x005D(0x0003)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AnimCompress_RemoveLinearKeys">();
	}
	static class UAnimCompress_RemoveLinearKeys* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAnimCompress_RemoveLinearKeys>();
	}
};
static_assert(alignof(UAnimCompress_RemoveLinearKeys) == 0x000008, "Wrong alignment on UAnimCompress_RemoveLinearKeys");
static_assert(sizeof(UAnimCompress_RemoveLinearKeys) == 0x000060, "Wrong size on UAnimCompress_RemoveLinearKeys");
static_assert(offsetof(UAnimCompress_RemoveLinearKeys, MaxPosDiff) == 0x000040, "Member 'UAnimCompress_RemoveLinearKeys::MaxPosDiff' has a wrong offset!");
static_assert(offsetof(UAnimCompress_RemoveLinearKeys, MaxAngleDiff) == 0x000044, "Member 'UAnimCompress_RemoveLinearKeys::MaxAngleDiff' has a wrong offset!");
static_assert(offsetof(UAnimCompress_RemoveLinearKeys, MaxScaleDiff) == 0x000048, "Member 'UAnimCompress_RemoveLinearKeys::MaxScaleDiff' has a wrong offset!");
static_assert(offsetof(UAnimCompress_RemoveLinearKeys, MaxEffectorDiff) == 0x00004C, "Member 'UAnimCompress_RemoveLinearKeys::MaxEffectorDiff' has a wrong offset!");
static_assert(offsetof(UAnimCompress_RemoveLinearKeys, MinEffectorDiff) == 0x000050, "Member 'UAnimCompress_RemoveLinearKeys::MinEffectorDiff' has a wrong offset!");
static_assert(offsetof(UAnimCompress_RemoveLinearKeys, EffectorDiffSocket) == 0x000054, "Member 'UAnimCompress_RemoveLinearKeys::EffectorDiffSocket' has a wrong offset!");
static_assert(offsetof(UAnimCompress_RemoveLinearKeys, ParentKeyScale) == 0x000058, "Member 'UAnimCompress_RemoveLinearKeys::ParentKeyScale' has a wrong offset!");

// Class Engine.AnimCompress_PerTrackCompression
// 0x0078 (0x00D8 - 0x0060)
class UAnimCompress_PerTrackCompression final : public UAnimCompress_RemoveLinearKeys
{
public:
	float                                         MaxZeroingThreshold;                               // 0x0060(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         MaxPosDiffBitwise;                                 // 0x0064(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         MaxAngleDiffBitwise;                               // 0x0068(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         MaxScaleDiffBitwise;                               // 0x006C(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TArray<EAnimationCompressionFormat>           AllowedRotationFormats;                            // 0x0070(0x0010)(Edit, ZeroConstructor, NativeAccessSpecifierPublic)
	TArray<EAnimationCompressionFormat>           AllowedTranslationFormats;                         // 0x0080(0x0010)(Edit, ZeroConstructor, NativeAccessSpecifierPublic)
	TArray<EAnimationCompressionFormat>           AllowedScaleFormats;                               // 0x0090(0x0010)(Edit, ZeroConstructor, NativeAccessSpecifierPublic)
	uint8                                         bResampleAnimation : 1;                            // 0x00A0(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_A1[0x3];                                       // 0x00A1(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         ResampledFramerate;                                // 0x00A4(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         MinKeysForResampling;                              // 0x00A8(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bUseAdaptiveError : 1;                             // 0x00AC(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bUseOverrideForEndEffectors : 1;                   // 0x00AC(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_AD[0x3];                                       // 0x00AD(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	int32                                         TrackHeightBias;                                   // 0x00B0(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         ParentingDivisor;                                  // 0x00B4(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         ParentingDivisorExponent;                          // 0x00B8(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bUseAdaptiveError2 : 1;                            // 0x00BC(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_BD[0x3];                                       // 0x00BD(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         RotationErrorSourceRatio;                          // 0x00C0(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         TranslationErrorSourceRatio;                       // 0x00C4(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         ScaleErrorSourceRatio;                             // 0x00C8(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         MaxErrorPerTrackRatio;                             // 0x00CC(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         PerturbationProbeSize;                             // 0x00D0(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_D4[0x4];                                       // 0x00D4(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AnimCompress_PerTrackCompression">();
	}
	static class UAnimCompress_PerTrackCompression* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAnimCompress_PerTrackCompression>();
	}
};
static_assert(alignof(UAnimCompress_PerTrackCompression) == 0x000008, "Wrong alignment on UAnimCompress_PerTrackCompression");
static_assert(sizeof(UAnimCompress_PerTrackCompression) == 0x0000D8, "Wrong size on UAnimCompress_PerTrackCompression");
static_assert(offsetof(UAnimCompress_PerTrackCompression, MaxZeroingThreshold) == 0x000060, "Member 'UAnimCompress_PerTrackCompression::MaxZeroingThreshold' has a wrong offset!");
static_assert(offsetof(UAnimCompress_PerTrackCompression, MaxPosDiffBitwise) == 0x000064, "Member 'UAnimCompress_PerTrackCompression::MaxPosDiffBitwise' has a wrong offset!");
static_assert(offsetof(UAnimCompress_PerTrackCompression, MaxAngleDiffBitwise) == 0x000068, "Member 'UAnimCompress_PerTrackCompression::MaxAngleDiffBitwise' has a wrong offset!");
static_assert(offsetof(UAnimCompress_PerTrackCompression, MaxScaleDiffBitwise) == 0x00006C, "Member 'UAnimCompress_PerTrackCompression::MaxScaleDiffBitwise' has a wrong offset!");
static_assert(offsetof(UAnimCompress_PerTrackCompression, AllowedRotationFormats) == 0x000070, "Member 'UAnimCompress_PerTrackCompression::AllowedRotationFormats' has a wrong offset!");
static_assert(offsetof(UAnimCompress_PerTrackCompression, AllowedTranslationFormats) == 0x000080, "Member 'UAnimCompress_PerTrackCompression::AllowedTranslationFormats' has a wrong offset!");
static_assert(offsetof(UAnimCompress_PerTrackCompression, AllowedScaleFormats) == 0x000090, "Member 'UAnimCompress_PerTrackCompression::AllowedScaleFormats' has a wrong offset!");
static_assert(offsetof(UAnimCompress_PerTrackCompression, ResampledFramerate) == 0x0000A4, "Member 'UAnimCompress_PerTrackCompression::ResampledFramerate' has a wrong offset!");
static_assert(offsetof(UAnimCompress_PerTrackCompression, MinKeysForResampling) == 0x0000A8, "Member 'UAnimCompress_PerTrackCompression::MinKeysForResampling' has a wrong offset!");
static_assert(offsetof(UAnimCompress_PerTrackCompression, TrackHeightBias) == 0x0000B0, "Member 'UAnimCompress_PerTrackCompression::TrackHeightBias' has a wrong offset!");
static_assert(offsetof(UAnimCompress_PerTrackCompression, ParentingDivisor) == 0x0000B4, "Member 'UAnimCompress_PerTrackCompression::ParentingDivisor' has a wrong offset!");
static_assert(offsetof(UAnimCompress_PerTrackCompression, ParentingDivisorExponent) == 0x0000B8, "Member 'UAnimCompress_PerTrackCompression::ParentingDivisorExponent' has a wrong offset!");
static_assert(offsetof(UAnimCompress_PerTrackCompression, RotationErrorSourceRatio) == 0x0000C0, "Member 'UAnimCompress_PerTrackCompression::RotationErrorSourceRatio' has a wrong offset!");
static_assert(offsetof(UAnimCompress_PerTrackCompression, TranslationErrorSourceRatio) == 0x0000C4, "Member 'UAnimCompress_PerTrackCompression::TranslationErrorSourceRatio' has a wrong offset!");
static_assert(offsetof(UAnimCompress_PerTrackCompression, ScaleErrorSourceRatio) == 0x0000C8, "Member 'UAnimCompress_PerTrackCompression::ScaleErrorSourceRatio' has a wrong offset!");
static_assert(offsetof(UAnimCompress_PerTrackCompression, MaxErrorPerTrackRatio) == 0x0000CC, "Member 'UAnimCompress_PerTrackCompression::MaxErrorPerTrackRatio' has a wrong offset!");
static_assert(offsetof(UAnimCompress_PerTrackCompression, PerturbationProbeSize) == 0x0000D0, "Member 'UAnimCompress_PerTrackCompression::PerturbationProbeSize' has a wrong offset!");

// Class Engine.ReverbEffect
// 0x0038 (0x0060 - 0x0028)
class UReverbEffect final : public UObject
{
public:
	bool                                          bBypassEarlyReflections;                           // 0x0028(0x0001)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_29[0x3];                                       // 0x0029(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         ReflectionsDelay;                                  // 0x002C(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         GainHF;                                            // 0x0030(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         ReflectionsGain;                                   // 0x0034(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bBypassLateReflections;                            // 0x0038(0x0001)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_39[0x3];                                       // 0x0039(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         LateDelay;                                         // 0x003C(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         DecayTime;                                         // 0x0040(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         Density;                                           // 0x0044(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         Diffusion;                                         // 0x0048(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         AirAbsorptionGainHF;                               // 0x004C(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         DecayHFRatio;                                      // 0x0050(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         LateGain;                                          // 0x0054(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         Gain;                                              // 0x0058(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         RoomRolloffFactor;                                 // 0x005C(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ReverbEffect">();
	}
	static class UReverbEffect* GetDefaultObj()
	{
		return GetDefaultObjImpl<UReverbEffect>();
	}
};
static_assert(alignof(UReverbEffect) == 0x000008, "Wrong alignment on UReverbEffect");
static_assert(sizeof(UReverbEffect) == 0x000060, "Wrong size on UReverbEffect");
static_assert(offsetof(UReverbEffect, bBypassEarlyReflections) == 0x000028, "Member 'UReverbEffect::bBypassEarlyReflections' has a wrong offset!");
static_assert(offsetof(UReverbEffect, ReflectionsDelay) == 0x00002C, "Member 'UReverbEffect::ReflectionsDelay' has a wrong offset!");
static_assert(offsetof(UReverbEffect, GainHF) == 0x000030, "Member 'UReverbEffect::GainHF' has a wrong offset!");
static_assert(offsetof(UReverbEffect, ReflectionsGain) == 0x000034, "Member 'UReverbEffect::ReflectionsGain' has a wrong offset!");
static_assert(offsetof(UReverbEffect, bBypassLateReflections) == 0x000038, "Member 'UReverbEffect::bBypassLateReflections' has a wrong offset!");
static_assert(offsetof(UReverbEffect, LateDelay) == 0x00003C, "Member 'UReverbEffect::LateDelay' has a wrong offset!");
static_assert(offsetof(UReverbEffect, DecayTime) == 0x000040, "Member 'UReverbEffect::DecayTime' has a wrong offset!");
static_assert(offsetof(UReverbEffect, Density) == 0x000044, "Member 'UReverbEffect::Density' has a wrong offset!");
static_assert(offsetof(UReverbEffect, Diffusion) == 0x000048, "Member 'UReverbEffect::Diffusion' has a wrong offset!");
static_assert(offsetof(UReverbEffect, AirAbsorptionGainHF) == 0x00004C, "Member 'UReverbEffect::AirAbsorptionGainHF' has a wrong offset!");
static_assert(offsetof(UReverbEffect, DecayHFRatio) == 0x000050, "Member 'UReverbEffect::DecayHFRatio' has a wrong offset!");
static_assert(offsetof(UReverbEffect, LateGain) == 0x000054, "Member 'UReverbEffect::LateGain' has a wrong offset!");
static_assert(offsetof(UReverbEffect, Gain) == 0x000058, "Member 'UReverbEffect::Gain' has a wrong offset!");
static_assert(offsetof(UReverbEffect, RoomRolloffFactor) == 0x00005C, "Member 'UReverbEffect::RoomRolloffFactor' has a wrong offset!");

// Class Engine.MaterialExpressionCrossProduct
// 0x0050 (0x0100 - 0x00B0)
class UMaterialExpressionCrossProduct final : public UMaterialExpression
{
public:
	struct FExpressionInput                       A;                                                 // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       B;                                                 // 0x00D8(0x0028)(NoDestructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionCrossProduct">();
	}
	static class UMaterialExpressionCrossProduct* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionCrossProduct>();
	}
};
static_assert(alignof(UMaterialExpressionCrossProduct) == 0x000008, "Wrong alignment on UMaterialExpressionCrossProduct");
static_assert(sizeof(UMaterialExpressionCrossProduct) == 0x000100, "Wrong size on UMaterialExpressionCrossProduct");
static_assert(offsetof(UMaterialExpressionCrossProduct, A) == 0x0000B0, "Member 'UMaterialExpressionCrossProduct::A' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionCrossProduct, B) == 0x0000D8, "Member 'UMaterialExpressionCrossProduct::B' has a wrong offset!");

// Class Engine.AnimCompositeBase
// 0x0008 (0x00B8 - 0x00B0)
class UAnimCompositeBase : public UAnimSequenceBase
{
public:
	struct FFrameRate                             CommonTargetFrameRate;                             // 0x00B0(0x0008)(Edit, ZeroConstructor, EditConst, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AnimCompositeBase">();
	}
	static class UAnimCompositeBase* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAnimCompositeBase>();
	}
};
static_assert(alignof(UAnimCompositeBase) == 0x000008, "Wrong alignment on UAnimCompositeBase");
static_assert(sizeof(UAnimCompositeBase) == 0x0000B8, "Wrong size on UAnimCompositeBase");
static_assert(offsetof(UAnimCompositeBase, CommonTargetFrameRate) == 0x0000B0, "Member 'UAnimCompositeBase::CommonTargetFrameRate' has a wrong offset!");

// Class Engine.LightMapTexture2D
// 0x0000 (0x0280 - 0x0280)
class ULightMapTexture2D final : public UTexture2D
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"LightMapTexture2D">();
	}
	static class ULightMapTexture2D* GetDefaultObj()
	{
		return GetDefaultObjImpl<ULightMapTexture2D>();
	}
};
static_assert(alignof(ULightMapTexture2D) == 0x000010, "Wrong alignment on ULightMapTexture2D");
static_assert(sizeof(ULightMapTexture2D) == 0x000280, "Wrong size on ULightMapTexture2D");

// Class Engine.LightmassPortal
// 0x0008 (0x02A8 - 0x02A0)
class ALightmassPortal final : public AActor
{
public:
	class ULightmassPortalComponent*              PortalComponent;                                   // 0x02A0(0x0008)(Edit, BlueprintVisible, ExportObject, BlueprintReadOnly, ZeroConstructor, EditConst, InstancedReference, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"LightmassPortal">();
	}
	static class ALightmassPortal* GetDefaultObj()
	{
		return GetDefaultObjImpl<ALightmassPortal>();
	}
};
static_assert(alignof(ALightmassPortal) == 0x000008, "Wrong alignment on ALightmassPortal");
static_assert(sizeof(ALightmassPortal) == 0x0002A8, "Wrong size on ALightmassPortal");
static_assert(offsetof(ALightmassPortal, PortalComponent) == 0x0002A0, "Member 'ALightmassPortal::PortalComponent' has a wrong offset!");

// Class Engine.MaterialExpressionCollectionParameter
// 0x0020 (0x00D0 - 0x00B0)
class UMaterialExpressionCollectionParameter final : public UMaterialExpression
{
public:
	class UMaterialParameterCollection*           Collection;                                        // 0x00B0(0x0008)(Edit, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FName                                   ParameterName;                                     // 0x00B8(0x0008)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FGuid                                  ParameterId;                                       // 0x00C0(0x0010)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionCollectionParameter">();
	}
	static class UMaterialExpressionCollectionParameter* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionCollectionParameter>();
	}
};
static_assert(alignof(UMaterialExpressionCollectionParameter) == 0x000008, "Wrong alignment on UMaterialExpressionCollectionParameter");
static_assert(sizeof(UMaterialExpressionCollectionParameter) == 0x0000D0, "Wrong size on UMaterialExpressionCollectionParameter");
static_assert(offsetof(UMaterialExpressionCollectionParameter, Collection) == 0x0000B0, "Member 'UMaterialExpressionCollectionParameter::Collection' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionCollectionParameter, ParameterName) == 0x0000B8, "Member 'UMaterialExpressionCollectionParameter::ParameterName' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionCollectionParameter, ParameterId) == 0x0000C0, "Member 'UMaterialExpressionCollectionParameter::ParameterId' has a wrong offset!");

// Class Engine.LightmassPortalComponent
// 0x0010 (0x02B0 - 0x02A0)
class ULightmassPortalComponent final : public USceneComponent
{
public:
	class UBoxComponent*                          PreviewBox;                                        // 0x02A0(0x0008)(ExportObject, ZeroConstructor, InstancedReference, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_2A8[0x8];                                      // 0x02A8(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"LightmassPortalComponent">();
	}
	static class ULightmassPortalComponent* GetDefaultObj()
	{
		return GetDefaultObjImpl<ULightmassPortalComponent>();
	}
};
static_assert(alignof(ULightmassPortalComponent) == 0x000010, "Wrong alignment on ULightmassPortalComponent");
static_assert(sizeof(ULightmassPortalComponent) == 0x0002B0, "Wrong size on ULightmassPortalComponent");
static_assert(offsetof(ULightmassPortalComponent, PreviewBox) == 0x0002A0, "Member 'ULightmassPortalComponent::PreviewBox' has a wrong offset!");

// Class Engine.DecalComponent
// 0x0060 (0x0300 - 0x02A0)
class UDecalComponent final : public USceneComponent
{
public:
	class UMaterialInterface*                     DecalMaterial;                                     // 0x02A0(0x0008)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, NoDestructor, Protected, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	int32                                         SortOrder;                                         // 0x02A8(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         FadeScreenSize;                                    // 0x02AC(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         FadeStartDelay;                                    // 0x02B0(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         FadeDuration;                                      // 0x02B4(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         FadeInDuration;                                    // 0x02B8(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         FadeInStartDelay;                                  // 0x02BC(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bDestroyOwnerAfterFade : 1;                        // 0x02C0(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_2C1[0x7];                                      // 0x02C1(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	struct FVector                                DecalSize;                                         // 0x02C8(0x0018)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FLinearColor                           DecalColor;                                        // 0x02E0(0x0010)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_2F0[0x10];                                     // 0x02F0(0x0010)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	class UMaterialInstanceDynamic* CreateDynamicMaterialInstance();
	void SetDecalColor(const struct FLinearColor& Color);
	void SetDecalMaterial(class UMaterialInterface* NewDecalMaterial);
	void SetFadeIn(float StartDelay, float Duration);
	void SetFadeOut(float StartDelay, float Duration, bool DestroyOwnerAfterFade);
	void SetFadeScreenSize(float NewFadeScreenSize);
	void SetSortOrder(int32 Value);

	class UMaterialInterface* GetDecalMaterial() const;
	float GetFadeDuration() const;
	float GetFadeInDuration() const;
	float GetFadeInStartDelay() const;
	float GetFadeStartDelay() const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"DecalComponent">();
	}
	static class UDecalComponent* GetDefaultObj()
	{
		return GetDefaultObjImpl<UDecalComponent>();
	}
};
static_assert(alignof(UDecalComponent) == 0x000010, "Wrong alignment on UDecalComponent");
static_assert(sizeof(UDecalComponent) == 0x000300, "Wrong size on UDecalComponent");
static_assert(offsetof(UDecalComponent, DecalMaterial) == 0x0002A0, "Member 'UDecalComponent::DecalMaterial' has a wrong offset!");
static_assert(offsetof(UDecalComponent, SortOrder) == 0x0002A8, "Member 'UDecalComponent::SortOrder' has a wrong offset!");
static_assert(offsetof(UDecalComponent, FadeScreenSize) == 0x0002AC, "Member 'UDecalComponent::FadeScreenSize' has a wrong offset!");
static_assert(offsetof(UDecalComponent, FadeStartDelay) == 0x0002B0, "Member 'UDecalComponent::FadeStartDelay' has a wrong offset!");
static_assert(offsetof(UDecalComponent, FadeDuration) == 0x0002B4, "Member 'UDecalComponent::FadeDuration' has a wrong offset!");
static_assert(offsetof(UDecalComponent, FadeInDuration) == 0x0002B8, "Member 'UDecalComponent::FadeInDuration' has a wrong offset!");
static_assert(offsetof(UDecalComponent, FadeInStartDelay) == 0x0002BC, "Member 'UDecalComponent::FadeInStartDelay' has a wrong offset!");
static_assert(offsetof(UDecalComponent, DecalSize) == 0x0002C8, "Member 'UDecalComponent::DecalSize' has a wrong offset!");
static_assert(offsetof(UDecalComponent, DecalColor) == 0x0002E0, "Member 'UDecalComponent::DecalColor' has a wrong offset!");

// Class Engine.Texture2DDynamic
// 0x0010 (0x01E0 - 0x01D0)
class UTexture2DDynamic final : public UTexture
{
public:
	uint8                                         Pad_1C8[0x8];                                      // 0x01C8(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	EPixelFormat                                  Format;                                            // 0x01D0(0x0001)(ZeroConstructor, Transient, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1D1[0xF];                                      // 0x01D1(0x000F)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"Texture2DDynamic">();
	}
	static class UTexture2DDynamic* GetDefaultObj()
	{
		return GetDefaultObjImpl<UTexture2DDynamic>();
	}
};
static_assert(alignof(UTexture2DDynamic) == 0x000010, "Wrong alignment on UTexture2DDynamic");
static_assert(sizeof(UTexture2DDynamic) == 0x0001E0, "Wrong size on UTexture2DDynamic");
static_assert(offsetof(UTexture2DDynamic, Format) == 0x0001D0, "Member 'UTexture2DDynamic::Format' has a wrong offset!");

// Class Engine.MaterialExpressionLogarithm
// 0x0028 (0x00D8 - 0x00B0)
class UMaterialExpressionLogarithm final : public UMaterialExpression
{
public:
	struct FExpressionInput                       Input;                                             // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionLogarithm">();
	}
	static class UMaterialExpressionLogarithm* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionLogarithm>();
	}
};
static_assert(alignof(UMaterialExpressionLogarithm) == 0x000008, "Wrong alignment on UMaterialExpressionLogarithm");
static_assert(sizeof(UMaterialExpressionLogarithm) == 0x0000D8, "Wrong size on UMaterialExpressionLogarithm");
static_assert(offsetof(UMaterialExpressionLogarithm, Input) == 0x0000B0, "Member 'UMaterialExpressionLogarithm::Input' has a wrong offset!");

// Class Engine.LocalHeightFog
// 0x0008 (0x02A8 - 0x02A0)
class ALocalHeightFog final : public AInfo
{
public:
	class ULocalHeightFogComponent*               LocalHeightFogVolume;                              // 0x02A0(0x0008)(Edit, BlueprintVisible, ExportObject, BlueprintReadOnly, ZeroConstructor, EditConst, InstancedReference, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"LocalHeightFog">();
	}
	static class ALocalHeightFog* GetDefaultObj()
	{
		return GetDefaultObjImpl<ALocalHeightFog>();
	}
};
static_assert(alignof(ALocalHeightFog) == 0x000008, "Wrong alignment on ALocalHeightFog");
static_assert(sizeof(ALocalHeightFog) == 0x0002A8, "Wrong size on ALocalHeightFog");
static_assert(offsetof(ALocalHeightFog, LocalHeightFogVolume) == 0x0002A0, "Member 'ALocalHeightFog::LocalHeightFogVolume' has a wrong offset!");

// Class Engine.MapBuildDataRegistry
// 0x0210 (0x0238 - 0x0028)
class UMapBuildDataRegistry final : public UObject
{
public:
	ELightingBuildQuality                         LevelLightingQuality;                              // 0x0028(0x0001)(Edit, ZeroConstructor, EditConst, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_29[0x20F];                                     // 0x0029(0x020F)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MapBuildDataRegistry">();
	}
	static class UMapBuildDataRegistry* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMapBuildDataRegistry>();
	}
};
static_assert(alignof(UMapBuildDataRegistry) == 0x000008, "Wrong alignment on UMapBuildDataRegistry");
static_assert(sizeof(UMapBuildDataRegistry) == 0x000238, "Wrong size on UMapBuildDataRegistry");
static_assert(offsetof(UMapBuildDataRegistry, LevelLightingQuality) == 0x000028, "Member 'UMapBuildDataRegistry::LevelLightingQuality' has a wrong offset!");

// Class Engine.InterpToMovementComponent
// 0x00B0 (0x01C0 - 0x0110)
class UInterpToMovementComponent final : public UMovementComponent
{
public:
	float                                         Duration;                                          // 0x0110(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bPauseOnImpact : 1;                                // 0x0114(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_115[0x3];                                      // 0x0115(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	bool                                          bSweep;                                            // 0x0118(0x0001)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	ETeleportType                                 TeleportType;                                      // 0x0119(0x0001)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EInterpToBehaviourType                        BehaviourType;                                     // 0x011A(0x0001)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bCheckIfStillInWorld;                              // 0x011B(0x0001)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bForceSubStepping : 1;                             // 0x011C(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_11D[0x3];                                      // 0x011D(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	TMulticastInlineDelegate<void(const struct FHitResult& ImpactResult, float Time)> OnInterpToReverse; // 0x0120(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	TMulticastInlineDelegate<void(const struct FHitResult& ImpactResult, float Time)> OnInterpToStop; // 0x0130(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	TMulticastInlineDelegate<void(const struct FHitResult& ImpactResult, float Time)> OnWaitBeginDelegate; // 0x0140(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	TMulticastInlineDelegate<void(const struct FHitResult& ImpactResult, float Time)> OnWaitEndDelegate; // 0x0150(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	TMulticastInlineDelegate<void(const struct FHitResult& ImpactResult, float Time)> OnResetDelegate; // 0x0160(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	float                                         MaxSimulationTimeStep;                             // 0x0170(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         MaxSimulationIterations;                           // 0x0174(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TArray<struct FInterpControlPoint>            ControlPoints;                                     // 0x0178(0x0010)(Edit, BlueprintVisible, ZeroConstructor, NativeAccessSpecifierPublic)
	uint8                                         Pad_188[0x38];                                     // 0x0188(0x0038)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void AddControlPointPosition(const struct FVector& Pos, bool bPositionIsRelative);
	void FinaliseControlPoints();
	void ResetControlPoints();
	void RestartMovement(float InitialDirection);
	void StopSimulating(const struct FHitResult& HitResult);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"InterpToMovementComponent">();
	}
	static class UInterpToMovementComponent* GetDefaultObj()
	{
		return GetDefaultObjImpl<UInterpToMovementComponent>();
	}
};
static_assert(alignof(UInterpToMovementComponent) == 0x000008, "Wrong alignment on UInterpToMovementComponent");
static_assert(sizeof(UInterpToMovementComponent) == 0x0001C0, "Wrong size on UInterpToMovementComponent");
static_assert(offsetof(UInterpToMovementComponent, Duration) == 0x000110, "Member 'UInterpToMovementComponent::Duration' has a wrong offset!");
static_assert(offsetof(UInterpToMovementComponent, bSweep) == 0x000118, "Member 'UInterpToMovementComponent::bSweep' has a wrong offset!");
static_assert(offsetof(UInterpToMovementComponent, TeleportType) == 0x000119, "Member 'UInterpToMovementComponent::TeleportType' has a wrong offset!");
static_assert(offsetof(UInterpToMovementComponent, BehaviourType) == 0x00011A, "Member 'UInterpToMovementComponent::BehaviourType' has a wrong offset!");
static_assert(offsetof(UInterpToMovementComponent, bCheckIfStillInWorld) == 0x00011B, "Member 'UInterpToMovementComponent::bCheckIfStillInWorld' has a wrong offset!");
static_assert(offsetof(UInterpToMovementComponent, OnInterpToReverse) == 0x000120, "Member 'UInterpToMovementComponent::OnInterpToReverse' has a wrong offset!");
static_assert(offsetof(UInterpToMovementComponent, OnInterpToStop) == 0x000130, "Member 'UInterpToMovementComponent::OnInterpToStop' has a wrong offset!");
static_assert(offsetof(UInterpToMovementComponent, OnWaitBeginDelegate) == 0x000140, "Member 'UInterpToMovementComponent::OnWaitBeginDelegate' has a wrong offset!");
static_assert(offsetof(UInterpToMovementComponent, OnWaitEndDelegate) == 0x000150, "Member 'UInterpToMovementComponent::OnWaitEndDelegate' has a wrong offset!");
static_assert(offsetof(UInterpToMovementComponent, OnResetDelegate) == 0x000160, "Member 'UInterpToMovementComponent::OnResetDelegate' has a wrong offset!");
static_assert(offsetof(UInterpToMovementComponent, MaxSimulationTimeStep) == 0x000170, "Member 'UInterpToMovementComponent::MaxSimulationTimeStep' has a wrong offset!");
static_assert(offsetof(UInterpToMovementComponent, MaxSimulationIterations) == 0x000174, "Member 'UInterpToMovementComponent::MaxSimulationIterations' has a wrong offset!");
static_assert(offsetof(UInterpToMovementComponent, ControlPoints) == 0x000178, "Member 'UInterpToMovementComponent::ControlPoints' has a wrong offset!");

// Class Engine.MaterialExpressionParticleSubUVProperties
// 0x0000 (0x00B0 - 0x00B0)
class UMaterialExpressionParticleSubUVProperties final : public UMaterialExpression
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionParticleSubUVProperties">();
	}
	static class UMaterialExpressionParticleSubUVProperties* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionParticleSubUVProperties>();
	}
};
static_assert(alignof(UMaterialExpressionParticleSubUVProperties) == 0x000008, "Wrong alignment on UMaterialExpressionParticleSubUVProperties");
static_assert(sizeof(UMaterialExpressionParticleSubUVProperties) == 0x0000B0, "Wrong size on UMaterialExpressionParticleSubUVProperties");

// Class Engine.MaterialExpressionAbs
// 0x0028 (0x00D8 - 0x00B0)
class UMaterialExpressionAbs final : public UMaterialExpression
{
public:
	struct FExpressionInput                       Input;                                             // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionAbs">();
	}
	static class UMaterialExpressionAbs* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionAbs>();
	}
};
static_assert(alignof(UMaterialExpressionAbs) == 0x000008, "Wrong alignment on UMaterialExpressionAbs");
static_assert(sizeof(UMaterialExpressionAbs) == 0x0000D8, "Wrong size on UMaterialExpressionAbs");
static_assert(offsetof(UMaterialExpressionAbs, Input) == 0x0000B0, "Member 'UMaterialExpressionAbs::Input' has a wrong offset!");

// Class Engine.AnimDataModel
// 0x00A0 (0x00C8 - 0x0028)
class UAnimDataModel final : public UObject
{
public:
	uint8                                         Pad_28[0x8];                                       // 0x0028(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	int32                                         BracketCounter;                                    // 0x0030(0x0004)(ZeroConstructor, Transient, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_34[0x4];                                       // 0x0034(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	TMulticastInlineDelegate<void(EAnimDataModelNotifyType NotifType, TScriptInterface<class IAnimationDataModel> Model, const struct FAnimDataModelNotifPayload& Payload)> ModifiedEventDynamic; // 0x0038(0x0010)(ZeroConstructor, Transient, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPrivate)
	uint8                                         Pad_48[0x18];                                      // 0x0048(0x0018)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<struct FBoneAnimationTrack>            BoneAnimationTracks;                               // 0x0060(0x0010)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, EditConst, NativeAccessSpecifierPrivate)
	float                                         PlayLength;                                        // 0x0070(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, EditConst, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	struct FFrameRate                             FrameRate;                                         // 0x0074(0x0008)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, EditConst, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	int32                                         NumberOfFrames;                                    // 0x007C(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, EditConst, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	int32                                         NumberOfKeys;                                      // 0x0080(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, EditConst, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_84[0x4];                                       // 0x0084(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	struct FAnimationCurveData                    CurveData;                                         // 0x0088(0x0020)(Edit, BlueprintVisible, BlueprintReadOnly, EditConst, NativeAccessSpecifierPrivate)
	TArray<struct FAnimatedBoneAttribute>         AnimatedBoneAttributes;                            // 0x00A8(0x0010)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, EditConst, NativeAccessSpecifierPrivate)
	bool                                          bPopulated;                                        // 0x00B8(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_B9[0xF];                                       // 0x00B9(0x000F)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AnimDataModel">();
	}
	static class UAnimDataModel* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAnimDataModel>();
	}
};
static_assert(alignof(UAnimDataModel) == 0x000008, "Wrong alignment on UAnimDataModel");
static_assert(sizeof(UAnimDataModel) == 0x0000C8, "Wrong size on UAnimDataModel");
static_assert(offsetof(UAnimDataModel, BracketCounter) == 0x000030, "Member 'UAnimDataModel::BracketCounter' has a wrong offset!");
static_assert(offsetof(UAnimDataModel, ModifiedEventDynamic) == 0x000038, "Member 'UAnimDataModel::ModifiedEventDynamic' has a wrong offset!");
static_assert(offsetof(UAnimDataModel, BoneAnimationTracks) == 0x000060, "Member 'UAnimDataModel::BoneAnimationTracks' has a wrong offset!");
static_assert(offsetof(UAnimDataModel, PlayLength) == 0x000070, "Member 'UAnimDataModel::PlayLength' has a wrong offset!");
static_assert(offsetof(UAnimDataModel, FrameRate) == 0x000074, "Member 'UAnimDataModel::FrameRate' has a wrong offset!");
static_assert(offsetof(UAnimDataModel, NumberOfFrames) == 0x00007C, "Member 'UAnimDataModel::NumberOfFrames' has a wrong offset!");
static_assert(offsetof(UAnimDataModel, NumberOfKeys) == 0x000080, "Member 'UAnimDataModel::NumberOfKeys' has a wrong offset!");
static_assert(offsetof(UAnimDataModel, CurveData) == 0x000088, "Member 'UAnimDataModel::CurveData' has a wrong offset!");
static_assert(offsetof(UAnimDataModel, AnimatedBoneAttributes) == 0x0000A8, "Member 'UAnimDataModel::AnimatedBoneAttributes' has a wrong offset!");
static_assert(offsetof(UAnimDataModel, bPopulated) == 0x0000B8, "Member 'UAnimDataModel::bPopulated' has a wrong offset!");

// Class Engine.MaterialExpressionAbsorptionMediumMaterialOutput
// 0x0028 (0x00D8 - 0x00B0)
class UMaterialExpressionAbsorptionMediumMaterialOutput final : public UMaterialExpressionCustomOutput
{
public:
	struct FExpressionInput                       TransmittanceColor;                                // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionAbsorptionMediumMaterialOutput">();
	}
	static class UMaterialExpressionAbsorptionMediumMaterialOutput* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionAbsorptionMediumMaterialOutput>();
	}
};
static_assert(alignof(UMaterialExpressionAbsorptionMediumMaterialOutput) == 0x000008, "Wrong alignment on UMaterialExpressionAbsorptionMediumMaterialOutput");
static_assert(sizeof(UMaterialExpressionAbsorptionMediumMaterialOutput) == 0x0000D8, "Wrong size on UMaterialExpressionAbsorptionMediumMaterialOutput");
static_assert(offsetof(UMaterialExpressionAbsorptionMediumMaterialOutput, TransmittanceColor) == 0x0000B0, "Member 'UMaterialExpressionAbsorptionMediumMaterialOutput::TransmittanceColor' has a wrong offset!");

// Class Engine.SkeletalMeshSimplificationSettings
// 0x0008 (0x0040 - 0x0038)
class USkeletalMeshSimplificationSettings final : public UDeveloperSettings
{
public:
	class FName                                   SkeletalMeshReductionModuleName;                   // 0x0038(0x0008)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"SkeletalMeshSimplificationSettings">();
	}
	static class USkeletalMeshSimplificationSettings* GetDefaultObj()
	{
		return GetDefaultObjImpl<USkeletalMeshSimplificationSettings>();
	}
};
static_assert(alignof(USkeletalMeshSimplificationSettings) == 0x000008, "Wrong alignment on USkeletalMeshSimplificationSettings");
static_assert(sizeof(USkeletalMeshSimplificationSettings) == 0x000040, "Wrong size on USkeletalMeshSimplificationSettings");
static_assert(offsetof(USkeletalMeshSimplificationSettings, SkeletalMeshReductionModuleName) == 0x000038, "Member 'USkeletalMeshSimplificationSettings::SkeletalMeshReductionModuleName' has a wrong offset!");

// Class Engine.MaterialExpressionActorPositionWS
// 0x0008 (0x00B8 - 0x00B0)
class UMaterialExpressionActorPositionWS final : public UMaterialExpression
{
public:
	EPositionOrigin                               OriginType;                                        // 0x00B0(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_B1[0x7];                                       // 0x00B1(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionActorPositionWS">();
	}
	static class UMaterialExpressionActorPositionWS* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionActorPositionWS>();
	}
};
static_assert(alignof(UMaterialExpressionActorPositionWS) == 0x000008, "Wrong alignment on UMaterialExpressionActorPositionWS");
static_assert(sizeof(UMaterialExpressionActorPositionWS) == 0x0000B8, "Wrong size on UMaterialExpressionActorPositionWS");
static_assert(offsetof(UMaterialExpressionActorPositionWS, OriginType) == 0x0000B0, "Member 'UMaterialExpressionActorPositionWS::OriginType' has a wrong offset!");

// Class Engine.AnimCompress_RemoveTrivialKeys
// 0x0010 (0x0050 - 0x0040)
class UAnimCompress_RemoveTrivialKeys final : public UAnimCompress
{
public:
	float                                         MaxPosDiff;                                        // 0x0040(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         MaxAngleDiff;                                      // 0x0044(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         MaxScaleDiff;                                      // 0x0048(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_4C[0x4];                                       // 0x004C(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AnimCompress_RemoveTrivialKeys">();
	}
	static class UAnimCompress_RemoveTrivialKeys* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAnimCompress_RemoveTrivialKeys>();
	}
};
static_assert(alignof(UAnimCompress_RemoveTrivialKeys) == 0x000008, "Wrong alignment on UAnimCompress_RemoveTrivialKeys");
static_assert(sizeof(UAnimCompress_RemoveTrivialKeys) == 0x000050, "Wrong size on UAnimCompress_RemoveTrivialKeys");
static_assert(offsetof(UAnimCompress_RemoveTrivialKeys, MaxPosDiff) == 0x000040, "Member 'UAnimCompress_RemoveTrivialKeys::MaxPosDiff' has a wrong offset!");
static_assert(offsetof(UAnimCompress_RemoveTrivialKeys, MaxAngleDiff) == 0x000044, "Member 'UAnimCompress_RemoveTrivialKeys::MaxAngleDiff' has a wrong offset!");
static_assert(offsetof(UAnimCompress_RemoveTrivialKeys, MaxScaleDiff) == 0x000048, "Member 'UAnimCompress_RemoveTrivialKeys::MaxScaleDiff' has a wrong offset!");

// Class Engine.MaterialExpressionAdd
// 0x0058 (0x0108 - 0x00B0)
class UMaterialExpressionAdd final : public UMaterialExpression
{
public:
	struct FExpressionInput                       A;                                                 // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       B;                                                 // 0x00D8(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	float                                         ConstA;                                            // 0x0100(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         ConstB;                                            // 0x0104(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionAdd">();
	}
	static class UMaterialExpressionAdd* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionAdd>();
	}
};
static_assert(alignof(UMaterialExpressionAdd) == 0x000008, "Wrong alignment on UMaterialExpressionAdd");
static_assert(sizeof(UMaterialExpressionAdd) == 0x000108, "Wrong size on UMaterialExpressionAdd");
static_assert(offsetof(UMaterialExpressionAdd, A) == 0x0000B0, "Member 'UMaterialExpressionAdd::A' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionAdd, B) == 0x0000D8, "Member 'UMaterialExpressionAdd::B' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionAdd, ConstA) == 0x000100, "Member 'UMaterialExpressionAdd::ConstA' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionAdd, ConstB) == 0x000104, "Member 'UMaterialExpressionAdd::ConstB' has a wrong offset!");

// Class Engine.MaterialExpressionTextureBase
// 0x0010 (0x00C0 - 0x00B0)
class UMaterialExpressionTextureBase : public UMaterialExpression
{
public:
	class UTexture*                               Texture;                                           // 0x00B0(0x0008)(Edit, BlueprintVisible, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EMaterialSamplerType                          SamplerType;                                       // 0x00B8(0x0001)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         IsDefaultMeshpaintTexture : 1;                     // 0x00B9(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_BA[0x6];                                       // 0x00BA(0x0006)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionTextureBase">();
	}
	static class UMaterialExpressionTextureBase* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionTextureBase>();
	}
};
static_assert(alignof(UMaterialExpressionTextureBase) == 0x000008, "Wrong alignment on UMaterialExpressionTextureBase");
static_assert(sizeof(UMaterialExpressionTextureBase) == 0x0000C0, "Wrong size on UMaterialExpressionTextureBase");
static_assert(offsetof(UMaterialExpressionTextureBase, Texture) == 0x0000B0, "Member 'UMaterialExpressionTextureBase::Texture' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionTextureBase, SamplerType) == 0x0000B8, "Member 'UMaterialExpressionTextureBase::SamplerType' has a wrong offset!");

// Class Engine.MaterialExpressionConstantBiasScale
// 0x0030 (0x00E0 - 0x00B0)
class UMaterialExpressionConstantBiasScale final : public UMaterialExpression
{
public:
	struct FExpressionInput                       Input;                                             // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	float                                         Bias;                                              // 0x00D8(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         Scale;                                             // 0x00DC(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionConstantBiasScale">();
	}
	static class UMaterialExpressionConstantBiasScale* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionConstantBiasScale>();
	}
};
static_assert(alignof(UMaterialExpressionConstantBiasScale) == 0x000008, "Wrong alignment on UMaterialExpressionConstantBiasScale");
static_assert(sizeof(UMaterialExpressionConstantBiasScale) == 0x0000E0, "Wrong size on UMaterialExpressionConstantBiasScale");
static_assert(offsetof(UMaterialExpressionConstantBiasScale, Input) == 0x0000B0, "Member 'UMaterialExpressionConstantBiasScale::Input' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionConstantBiasScale, Bias) == 0x0000D8, "Member 'UMaterialExpressionConstantBiasScale::Bias' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionConstantBiasScale, Scale) == 0x0000DC, "Member 'UMaterialExpressionConstantBiasScale::Scale' has a wrong offset!");

// Class Engine.MaterialExpressionTextureSample
// 0x00F8 (0x01B8 - 0x00C0)
class UMaterialExpressionTextureSample : public UMaterialExpressionTextureBase
{
public:
	struct FExpressionInput                       Coordinates;                                       // 0x00C0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       TextureObject;                                     // 0x00E8(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       MipValue;                                          // 0x0110(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       CoordinatesDX;                                     // 0x0138(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       CoordinatesDY;                                     // 0x0160(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       AutomaticViewMipBiasValue;                         // 0x0188(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	ETextureMipValueMode                          MipValueMode;                                      // 0x01B0(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	ESamplerSourceMode                            SamplerSource;                                     // 0x01B1(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         AutomaticViewMipBias : 1;                          // 0x01B2(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         ConstCoordinate;                                   // 0x01B3(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         ConstMipValue;                                     // 0x01B4(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionTextureSample">();
	}
	static class UMaterialExpressionTextureSample* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionTextureSample>();
	}
};
static_assert(alignof(UMaterialExpressionTextureSample) == 0x000008, "Wrong alignment on UMaterialExpressionTextureSample");
static_assert(sizeof(UMaterialExpressionTextureSample) == 0x0001B8, "Wrong size on UMaterialExpressionTextureSample");
static_assert(offsetof(UMaterialExpressionTextureSample, Coordinates) == 0x0000C0, "Member 'UMaterialExpressionTextureSample::Coordinates' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionTextureSample, TextureObject) == 0x0000E8, "Member 'UMaterialExpressionTextureSample::TextureObject' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionTextureSample, MipValue) == 0x000110, "Member 'UMaterialExpressionTextureSample::MipValue' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionTextureSample, CoordinatesDX) == 0x000138, "Member 'UMaterialExpressionTextureSample::CoordinatesDX' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionTextureSample, CoordinatesDY) == 0x000160, "Member 'UMaterialExpressionTextureSample::CoordinatesDY' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionTextureSample, AutomaticViewMipBiasValue) == 0x000188, "Member 'UMaterialExpressionTextureSample::AutomaticViewMipBiasValue' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionTextureSample, MipValueMode) == 0x0001B0, "Member 'UMaterialExpressionTextureSample::MipValueMode' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionTextureSample, SamplerSource) == 0x0001B1, "Member 'UMaterialExpressionTextureSample::SamplerSource' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionTextureSample, ConstCoordinate) == 0x0001B3, "Member 'UMaterialExpressionTextureSample::ConstCoordinate' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionTextureSample, ConstMipValue) == 0x0001B4, "Member 'UMaterialExpressionTextureSample::ConstMipValue' has a wrong offset!");

// Class Engine.HeterogeneousVolume
// 0x0008 (0x02A8 - 0x02A0)
class AHeterogeneousVolume final : public AInfo
{
public:
	class UHeterogeneousVolumeComponent*          HeterogeneousVolumeComponent;                      // 0x02A0(0x0008)(Edit, BlueprintVisible, ExportObject, BlueprintReadOnly, ZeroConstructor, EditConst, InstancedReference, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"HeterogeneousVolume">();
	}
	static class AHeterogeneousVolume* GetDefaultObj()
	{
		return GetDefaultObjImpl<AHeterogeneousVolume>();
	}
};
static_assert(alignof(AHeterogeneousVolume) == 0x000008, "Wrong alignment on AHeterogeneousVolume");
static_assert(sizeof(AHeterogeneousVolume) == 0x0002A8, "Wrong size on AHeterogeneousVolume");
static_assert(offsetof(AHeterogeneousVolume, HeterogeneousVolumeComponent) == 0x0002A0, "Member 'AHeterogeneousVolume::HeterogeneousVolumeComponent' has a wrong offset!");

// Class Engine.TriggerVolume
// 0x0000 (0x02D8 - 0x02D8)
class ATriggerVolume : public AVolume
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"TriggerVolume">();
	}
	static class ATriggerVolume* GetDefaultObj()
	{
		return GetDefaultObjImpl<ATriggerVolume>();
	}
};
static_assert(alignof(ATriggerVolume) == 0x000008, "Wrong alignment on ATriggerVolume");
static_assert(sizeof(ATriggerVolume) == 0x0002D8, "Wrong size on ATriggerVolume");

// Class Engine.MaterialExpressionMaterialProxyReplace
// 0x0050 (0x0100 - 0x00B0)
class UMaterialExpressionMaterialProxyReplace final : public UMaterialExpression
{
public:
	struct FExpressionInput                       Realtime;                                          // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       MaterialProxy;                                     // 0x00D8(0x0028)(NoDestructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionMaterialProxyReplace">();
	}
	static class UMaterialExpressionMaterialProxyReplace* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionMaterialProxyReplace>();
	}
};
static_assert(alignof(UMaterialExpressionMaterialProxyReplace) == 0x000008, "Wrong alignment on UMaterialExpressionMaterialProxyReplace");
static_assert(sizeof(UMaterialExpressionMaterialProxyReplace) == 0x000100, "Wrong size on UMaterialExpressionMaterialProxyReplace");
static_assert(offsetof(UMaterialExpressionMaterialProxyReplace, Realtime) == 0x0000B0, "Member 'UMaterialExpressionMaterialProxyReplace::Realtime' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionMaterialProxyReplace, MaterialProxy) == 0x0000D8, "Member 'UMaterialExpressionMaterialProxyReplace::MaterialProxy' has a wrong offset!");

// Class Engine.MaterialExpressionTextureSampleParameter
// 0x0088 (0x0240 - 0x01B8)
class UMaterialExpressionTextureSampleParameter : public UMaterialExpressionTextureSample
{
public:
	class FName                                   ParameterName;                                     // 0x01B8(0x0008)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FGuid                                  ExpressionGUID;                                    // 0x01C0(0x0010)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FName                                   Group;                                             // 0x01D0(0x0008)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         SortPriority;                                      // 0x01D8(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1DC[0x4];                                      // 0x01DC(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	struct FParameterChannelNames                 ChannelNames;                                      // 0x01E0(0x0060)(Edit, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionTextureSampleParameter">();
	}
	static class UMaterialExpressionTextureSampleParameter* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionTextureSampleParameter>();
	}
};
static_assert(alignof(UMaterialExpressionTextureSampleParameter) == 0x000008, "Wrong alignment on UMaterialExpressionTextureSampleParameter");
static_assert(sizeof(UMaterialExpressionTextureSampleParameter) == 0x000240, "Wrong size on UMaterialExpressionTextureSampleParameter");
static_assert(offsetof(UMaterialExpressionTextureSampleParameter, ParameterName) == 0x0001B8, "Member 'UMaterialExpressionTextureSampleParameter::ParameterName' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionTextureSampleParameter, ExpressionGUID) == 0x0001C0, "Member 'UMaterialExpressionTextureSampleParameter::ExpressionGUID' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionTextureSampleParameter, Group) == 0x0001D0, "Member 'UMaterialExpressionTextureSampleParameter::Group' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionTextureSampleParameter, SortPriority) == 0x0001D8, "Member 'UMaterialExpressionTextureSampleParameter::SortPriority' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionTextureSampleParameter, ChannelNames) == 0x0001E0, "Member 'UMaterialExpressionTextureSampleParameter::ChannelNames' has a wrong offset!");

// Class Engine.MaterialExpressionTextureSampleParameter2D
// 0x0000 (0x0240 - 0x0240)
class UMaterialExpressionTextureSampleParameter2D : public UMaterialExpressionTextureSampleParameter
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionTextureSampleParameter2D">();
	}
	static class UMaterialExpressionTextureSampleParameter2D* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionTextureSampleParameter2D>();
	}
};
static_assert(alignof(UMaterialExpressionTextureSampleParameter2D) == 0x000008, "Wrong alignment on UMaterialExpressionTextureSampleParameter2D");
static_assert(sizeof(UMaterialExpressionTextureSampleParameter2D) == 0x000240, "Wrong size on UMaterialExpressionTextureSampleParameter2D");

// Class Engine.SoundParameterControllerInterface
// 0x0000 (0x0000 - 0x0000)
class ISoundParameterControllerInterface final
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"SoundParameterControllerInterface">();
	}
	static class ISoundParameterControllerInterface* GetDefaultObj()
	{
		return GetDefaultObjImpl<ISoundParameterControllerInterface>();
	}

	class UObject* AsUObject()
	{
		return reinterpret_cast<UObject*>(this);
	}
	const class UObject* AsUObject() const
	{
		return reinterpret_cast<const UObject*>(this);
	}
};
static_assert(alignof(ISoundParameterControllerInterface) == 0x000001, "Wrong alignment on ISoundParameterControllerInterface");
static_assert(sizeof(ISoundParameterControllerInterface) == 0x000001, "Wrong size on ISoundParameterControllerInterface");

// Class Engine.MaterialExpressionFunctionOutput
// 0x0060 (0x0110 - 0x00B0)
class UMaterialExpressionFunctionOutput : public UMaterialExpression
{
public:
	class FName                                   OutputName;                                        // 0x00B0(0x0008)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FString                                 Description;                                       // 0x00B8(0x0010)(Edit, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         SortPriority;                                      // 0x00C8(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_CC[0x4];                                       // 0x00CC(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	struct FExpressionInput                       A;                                                 // 0x00D0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	uint8                                         bLastPreviewed : 1;                                // 0x00F8(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_F9[0x3];                                       // 0x00F9(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	struct FGuid                                  ID;                                                // 0x00FC(0x0010)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_10C[0x4];                                      // 0x010C(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionFunctionOutput">();
	}
	static class UMaterialExpressionFunctionOutput* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionFunctionOutput>();
	}
};
static_assert(alignof(UMaterialExpressionFunctionOutput) == 0x000008, "Wrong alignment on UMaterialExpressionFunctionOutput");
static_assert(sizeof(UMaterialExpressionFunctionOutput) == 0x000110, "Wrong size on UMaterialExpressionFunctionOutput");
static_assert(offsetof(UMaterialExpressionFunctionOutput, OutputName) == 0x0000B0, "Member 'UMaterialExpressionFunctionOutput::OutputName' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionFunctionOutput, Description) == 0x0000B8, "Member 'UMaterialExpressionFunctionOutput::Description' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionFunctionOutput, SortPriority) == 0x0000C8, "Member 'UMaterialExpressionFunctionOutput::SortPriority' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionFunctionOutput, A) == 0x0000D0, "Member 'UMaterialExpressionFunctionOutput::A' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionFunctionOutput, ID) == 0x0000FC, "Member 'UMaterialExpressionFunctionOutput::ID' has a wrong offset!");

// Class Engine.MaterialExpressionAntialiasedTextureMask
// 0x0008 (0x0248 - 0x0240)
class UMaterialExpressionAntialiasedTextureMask final : public UMaterialExpressionTextureSampleParameter2D
{
public:
	float                                         Threshold;                                         // 0x0240(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	ETextureColorChannel                          Channel;                                           // 0x0244(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_245[0x3];                                      // 0x0245(0x0003)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionAntialiasedTextureMask">();
	}
	static class UMaterialExpressionAntialiasedTextureMask* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionAntialiasedTextureMask>();
	}
};
static_assert(alignof(UMaterialExpressionAntialiasedTextureMask) == 0x000008, "Wrong alignment on UMaterialExpressionAntialiasedTextureMask");
static_assert(sizeof(UMaterialExpressionAntialiasedTextureMask) == 0x000248, "Wrong size on UMaterialExpressionAntialiasedTextureMask");
static_assert(offsetof(UMaterialExpressionAntialiasedTextureMask, Threshold) == 0x000240, "Member 'UMaterialExpressionAntialiasedTextureMask::Threshold' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionAntialiasedTextureMask, Channel) == 0x000244, "Member 'UMaterialExpressionAntialiasedTextureMask::Channel' has a wrong offset!");

// Class Engine.AnimNotifyState_Trail
// 0x0028 (0x0058 - 0x0030)
class UAnimNotifyState_Trail final : public UAnimNotifyState
{
public:
	class UParticleSystem*                        PSTemplate;                                        // 0x0030(0x0008)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FName                                   FirstSocketName;                                   // 0x0038(0x0008)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FName                                   SecondSocketName;                                  // 0x0040(0x0008)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	ETrailWidthMode                               WidthScaleMode;                                    // 0x0048(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_49[0x3];                                       // 0x0049(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	class FName                                   WidthScaleCurve;                                   // 0x004C(0x0008)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bRecycleSpawnedSystems : 1;                        // 0x0054(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_55[0x3];                                       // 0x0055(0x0003)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	class UParticleSystem* OverridePSTemplate(class USkeletalMeshComponent* meshComp, class UAnimSequenceBase* Animation) const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AnimNotifyState_Trail">();
	}
	static class UAnimNotifyState_Trail* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAnimNotifyState_Trail>();
	}
};
static_assert(alignof(UAnimNotifyState_Trail) == 0x000008, "Wrong alignment on UAnimNotifyState_Trail");
static_assert(sizeof(UAnimNotifyState_Trail) == 0x000058, "Wrong size on UAnimNotifyState_Trail");
static_assert(offsetof(UAnimNotifyState_Trail, PSTemplate) == 0x000030, "Member 'UAnimNotifyState_Trail::PSTemplate' has a wrong offset!");
static_assert(offsetof(UAnimNotifyState_Trail, FirstSocketName) == 0x000038, "Member 'UAnimNotifyState_Trail::FirstSocketName' has a wrong offset!");
static_assert(offsetof(UAnimNotifyState_Trail, SecondSocketName) == 0x000040, "Member 'UAnimNotifyState_Trail::SecondSocketName' has a wrong offset!");
static_assert(offsetof(UAnimNotifyState_Trail, WidthScaleMode) == 0x000048, "Member 'UAnimNotifyState_Trail::WidthScaleMode' has a wrong offset!");
static_assert(offsetof(UAnimNotifyState_Trail, WidthScaleCurve) == 0x00004C, "Member 'UAnimNotifyState_Trail::WidthScaleCurve' has a wrong offset!");

// Class Engine.MaterialExpressionAppendVector
// 0x0050 (0x0100 - 0x00B0)
class UMaterialExpressionAppendVector final : public UMaterialExpression
{
public:
	struct FExpressionInput                       A;                                                 // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       B;                                                 // 0x00D8(0x0028)(NoDestructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionAppendVector">();
	}
	static class UMaterialExpressionAppendVector* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionAppendVector>();
	}
};
static_assert(alignof(UMaterialExpressionAppendVector) == 0x000008, "Wrong alignment on UMaterialExpressionAppendVector");
static_assert(sizeof(UMaterialExpressionAppendVector) == 0x000100, "Wrong size on UMaterialExpressionAppendVector");
static_assert(offsetof(UMaterialExpressionAppendVector, A) == 0x0000B0, "Member 'UMaterialExpressionAppendVector::A' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionAppendVector, B) == 0x0000D8, "Member 'UMaterialExpressionAppendVector::B' has a wrong offset!");

// Class Engine.SoundMix
// 0x0068 (0x0090 - 0x0028)
class USoundMix final : public UObject
{
public:
	uint8                                         bApplyEQ : 1;                                      // 0x0028(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, AssetRegistrySearchable, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_29[0x3];                                       // 0x0029(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         EQPriority;                                        // 0x002C(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FAudioEQEffect                         EQSettings;                                        // 0x0030(0x0040)(Edit, NativeAccessSpecifierPublic)
	TArray<struct FSoundClassAdjuster>            SoundClassEffects;                                 // 0x0070(0x0010)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, NativeAccessSpecifierPublic)
	float                                         InitialDelay;                                      // 0x0080(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         FadeInTime;                                        // 0x0084(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         Duration;                                          // 0x0088(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         FadeOutTime;                                       // 0x008C(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"SoundMix">();
	}
	static class USoundMix* GetDefaultObj()
	{
		return GetDefaultObjImpl<USoundMix>();
	}
};
static_assert(alignof(USoundMix) == 0x000008, "Wrong alignment on USoundMix");
static_assert(sizeof(USoundMix) == 0x000090, "Wrong size on USoundMix");
static_assert(offsetof(USoundMix, EQPriority) == 0x00002C, "Member 'USoundMix::EQPriority' has a wrong offset!");
static_assert(offsetof(USoundMix, EQSettings) == 0x000030, "Member 'USoundMix::EQSettings' has a wrong offset!");
static_assert(offsetof(USoundMix, SoundClassEffects) == 0x000070, "Member 'USoundMix::SoundClassEffects' has a wrong offset!");
static_assert(offsetof(USoundMix, InitialDelay) == 0x000080, "Member 'USoundMix::InitialDelay' has a wrong offset!");
static_assert(offsetof(USoundMix, FadeInTime) == 0x000084, "Member 'USoundMix::FadeInTime' has a wrong offset!");
static_assert(offsetof(USoundMix, Duration) == 0x000088, "Member 'USoundMix::Duration' has a wrong offset!");
static_assert(offsetof(USoundMix, FadeOutTime) == 0x00008C, "Member 'USoundMix::FadeOutTime' has a wrong offset!");

// Class Engine.MaterialExpressionObjectLocalBounds
// 0x0000 (0x00B0 - 0x00B0)
class UMaterialExpressionObjectLocalBounds final : public UMaterialExpression
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionObjectLocalBounds">();
	}
	static class UMaterialExpressionObjectLocalBounds* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionObjectLocalBounds>();
	}
};
static_assert(alignof(UMaterialExpressionObjectLocalBounds) == 0x000008, "Wrong alignment on UMaterialExpressionObjectLocalBounds");
static_assert(sizeof(UMaterialExpressionObjectLocalBounds) == 0x0000B0, "Wrong size on UMaterialExpressionObjectLocalBounds");

// Class Engine.MaterialExpressionArccosine
// 0x0028 (0x00D8 - 0x00B0)
class UMaterialExpressionArccosine final : public UMaterialExpression
{
public:
	struct FExpressionInput                       Input;                                             // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionArccosine">();
	}
	static class UMaterialExpressionArccosine* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionArccosine>();
	}
};
static_assert(alignof(UMaterialExpressionArccosine) == 0x000008, "Wrong alignment on UMaterialExpressionArccosine");
static_assert(sizeof(UMaterialExpressionArccosine) == 0x0000D8, "Wrong size on UMaterialExpressionArccosine");
static_assert(offsetof(UMaterialExpressionArccosine, Input) == 0x0000B0, "Member 'UMaterialExpressionArccosine::Input' has a wrong offset!");

// Class Engine.AnimMontage
// 0x0128 (0x01E0 - 0x00B8)
class UAnimMontage final : public UAnimCompositeBase
{
public:
	EMontageBlendMode                             BlendModeIn;                                       // 0x00B8(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EMontageBlendMode                             BlendModeOut;                                      // 0x00B9(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_BA[0x6];                                       // 0x00BA(0x0006)(Fixing Size After Last Property [ Dumper-7 ])
	struct FAlphaBlend                            BlendIn;                                           // 0x00C0(0x0030)(Edit, NoDestructor, NativeAccessSpecifierPublic)
	struct FAlphaBlend                            BlendOut;                                          // 0x00F0(0x0030)(Edit, NoDestructor, NativeAccessSpecifierPublic)
	float                                         BlendOutTriggerTime;                               // 0x0120(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FName                                   SyncGroup;                                         // 0x0124(0x0008)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         SyncSlotIndex;                                     // 0x012C(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FMarkerSyncData                        MarkerData;                                        // 0x0130(0x0020)(NativeAccessSpecifierPublic)
	TArray<struct FCompositeSection>              CompositeSections;                                 // 0x0150(0x0010)(ZeroConstructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
	TArray<struct FSlotAnimationTrack>            SlotAnimTracks;                                    // 0x0160(0x0010)(ZeroConstructor, NativeAccessSpecifierPublic)
	bool                                          bEnableRootMotionTranslation;                      // 0x0170(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bEnableRootMotionRotation;                         // 0x0171(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bEnableAutoBlendOut;                               // 0x0172(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_173[0x5];                                      // 0x0173(0x0005)(Fixing Size After Last Property [ Dumper-7 ])
	class UBlendProfile*                          BlendProfileIn;                                    // 0x0178(0x0008)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UBlendProfile*                          BlendProfileOut;                                   // 0x0180(0x0008)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	ERootMotionRootLock                           RootMotionRootLock;                                // 0x0188(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_189[0x7];                                      // 0x0189(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<struct FBranchingPointMarker>          BranchingPointMarkers;                             // 0x0190(0x0010)(ZeroConstructor, NativeAccessSpecifierPrivate)
	TArray<int32>                                 BranchingPointStateNotifyIndices;                  // 0x01A0(0x0010)(ZeroConstructor, NativeAccessSpecifierPublic)
	struct FTimeStretchCurve                      TimeStretchCurve;                                  // 0x01B0(0x0028)(Edit, NativeAccessSpecifierPublic)
	class FName                                   TimeStretchCurveName;                              // 0x01D8(0x0008)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

public:
	static class UAnimMontage* CreateSlotAnimationAsDynamicMontage_WithBlendSettings(class UAnimSequenceBase* Asset, class FName SlotNodeName, const struct FMontageBlendSettings& BlendInSettings, const struct FMontageBlendSettings& BlendOutSettings, float InPlayRate, int32 LoopCount, float InBlendOutTriggerTime);

	struct FAlphaBlendArgs GetBlendInArgs() const;
	struct FAlphaBlendArgs GetBlendOutArgs() const;
	float GetDefaultBlendInTime() const;
	float GetDefaultBlendOutTime() const;
	class FName GetGroupName() const;
	int32 GetNumSections() const;
	int32 GetSectionIndex(class FName InSectionName) const;
	class FName GetSectionName(int32 SectionIndex) const;
	bool IsValidAdditiveSlot(const class FName& SlotNodeName) const;
	bool IsValidSectionName(class FName InSectionName) const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AnimMontage">();
	}
	static class UAnimMontage* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAnimMontage>();
	}
};
static_assert(alignof(UAnimMontage) == 0x000008, "Wrong alignment on UAnimMontage");
static_assert(sizeof(UAnimMontage) == 0x0001E0, "Wrong size on UAnimMontage");
static_assert(offsetof(UAnimMontage, BlendModeIn) == 0x0000B8, "Member 'UAnimMontage::BlendModeIn' has a wrong offset!");
static_assert(offsetof(UAnimMontage, BlendModeOut) == 0x0000B9, "Member 'UAnimMontage::BlendModeOut' has a wrong offset!");
static_assert(offsetof(UAnimMontage, BlendIn) == 0x0000C0, "Member 'UAnimMontage::BlendIn' has a wrong offset!");
static_assert(offsetof(UAnimMontage, BlendOut) == 0x0000F0, "Member 'UAnimMontage::BlendOut' has a wrong offset!");
static_assert(offsetof(UAnimMontage, BlendOutTriggerTime) == 0x000120, "Member 'UAnimMontage::BlendOutTriggerTime' has a wrong offset!");
static_assert(offsetof(UAnimMontage, SyncGroup) == 0x000124, "Member 'UAnimMontage::SyncGroup' has a wrong offset!");
static_assert(offsetof(UAnimMontage, SyncSlotIndex) == 0x00012C, "Member 'UAnimMontage::SyncSlotIndex' has a wrong offset!");
static_assert(offsetof(UAnimMontage, MarkerData) == 0x000130, "Member 'UAnimMontage::MarkerData' has a wrong offset!");
static_assert(offsetof(UAnimMontage, CompositeSections) == 0x000150, "Member 'UAnimMontage::CompositeSections' has a wrong offset!");
static_assert(offsetof(UAnimMontage, SlotAnimTracks) == 0x000160, "Member 'UAnimMontage::SlotAnimTracks' has a wrong offset!");
static_assert(offsetof(UAnimMontage, bEnableRootMotionTranslation) == 0x000170, "Member 'UAnimMontage::bEnableRootMotionTranslation' has a wrong offset!");
static_assert(offsetof(UAnimMontage, bEnableRootMotionRotation) == 0x000171, "Member 'UAnimMontage::bEnableRootMotionRotation' has a wrong offset!");
static_assert(offsetof(UAnimMontage, bEnableAutoBlendOut) == 0x000172, "Member 'UAnimMontage::bEnableAutoBlendOut' has a wrong offset!");
static_assert(offsetof(UAnimMontage, BlendProfileIn) == 0x000178, "Member 'UAnimMontage::BlendProfileIn' has a wrong offset!");
static_assert(offsetof(UAnimMontage, BlendProfileOut) == 0x000180, "Member 'UAnimMontage::BlendProfileOut' has a wrong offset!");
static_assert(offsetof(UAnimMontage, RootMotionRootLock) == 0x000188, "Member 'UAnimMontage::RootMotionRootLock' has a wrong offset!");
static_assert(offsetof(UAnimMontage, BranchingPointMarkers) == 0x000190, "Member 'UAnimMontage::BranchingPointMarkers' has a wrong offset!");
static_assert(offsetof(UAnimMontage, BranchingPointStateNotifyIndices) == 0x0001A0, "Member 'UAnimMontage::BranchingPointStateNotifyIndices' has a wrong offset!");
static_assert(offsetof(UAnimMontage, TimeStretchCurve) == 0x0001B0, "Member 'UAnimMontage::TimeStretchCurve' has a wrong offset!");
static_assert(offsetof(UAnimMontage, TimeStretchCurveName) == 0x0001D8, "Member 'UAnimMontage::TimeStretchCurveName' has a wrong offset!");

// Class Engine.MaterialExpressionArccosineFast
// 0x0028 (0x00D8 - 0x00B0)
class UMaterialExpressionArccosineFast final : public UMaterialExpression
{
public:
	struct FExpressionInput                       Input;                                             // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionArccosineFast">();
	}
	static class UMaterialExpressionArccosineFast* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionArccosineFast>();
	}
};
static_assert(alignof(UMaterialExpressionArccosineFast) == 0x000008, "Wrong alignment on UMaterialExpressionArccosineFast");
static_assert(sizeof(UMaterialExpressionArccosineFast) == 0x0000D8, "Wrong size on UMaterialExpressionArccosineFast");
static_assert(offsetof(UMaterialExpressionArccosineFast, Input) == 0x0000B0, "Member 'UMaterialExpressionArccosineFast::Input' has a wrong offset!");

// Class Engine.MaterialExpressionArcsine
// 0x0028 (0x00D8 - 0x00B0)
class UMaterialExpressionArcsine final : public UMaterialExpression
{
public:
	struct FExpressionInput                       Input;                                             // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionArcsine">();
	}
	static class UMaterialExpressionArcsine* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionArcsine>();
	}
};
static_assert(alignof(UMaterialExpressionArcsine) == 0x000008, "Wrong alignment on UMaterialExpressionArcsine");
static_assert(sizeof(UMaterialExpressionArcsine) == 0x0000D8, "Wrong size on UMaterialExpressionArcsine");
static_assert(offsetof(UMaterialExpressionArcsine, Input) == 0x0000B0, "Member 'UMaterialExpressionArcsine::Input' has a wrong offset!");

// Class Engine.MaterialExpressionDDX
// 0x0028 (0x00D8 - 0x00B0)
class UMaterialExpressionDDX final : public UMaterialExpression
{
public:
	struct FExpressionInput                       Value;                                             // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionDDX">();
	}
	static class UMaterialExpressionDDX* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionDDX>();
	}
};
static_assert(alignof(UMaterialExpressionDDX) == 0x000008, "Wrong alignment on UMaterialExpressionDDX");
static_assert(sizeof(UMaterialExpressionDDX) == 0x0000D8, "Wrong size on UMaterialExpressionDDX");
static_assert(offsetof(UMaterialExpressionDDX, Value) == 0x0000B0, "Member 'UMaterialExpressionDDX::Value' has a wrong offset!");

// Class Engine.MaterialExpressionArcsineFast
// 0x0028 (0x00D8 - 0x00B0)
class UMaterialExpressionArcsineFast final : public UMaterialExpression
{
public:
	struct FExpressionInput                       Input;                                             // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionArcsineFast">();
	}
	static class UMaterialExpressionArcsineFast* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionArcsineFast>();
	}
};
static_assert(alignof(UMaterialExpressionArcsineFast) == 0x000008, "Wrong alignment on UMaterialExpressionArcsineFast");
static_assert(sizeof(UMaterialExpressionArcsineFast) == 0x0000D8, "Wrong size on UMaterialExpressionArcsineFast");
static_assert(offsetof(UMaterialExpressionArcsineFast, Input) == 0x0000B0, "Member 'UMaterialExpressionArcsineFast::Input' has a wrong offset!");

// Class Engine.ActorSoundParameterInterface
// 0x0000 (0x0000 - 0x0000)
class IActorSoundParameterInterface final
{
public:
	void GetActorSoundParams(TArray<struct FAudioParameter>* params) const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ActorSoundParameterInterface">();
	}
	static class IActorSoundParameterInterface* GetDefaultObj()
	{
		return GetDefaultObjImpl<IActorSoundParameterInterface>();
	}

	class UObject* AsUObject()
	{
		return reinterpret_cast<UObject*>(this);
	}
	const class UObject* AsUObject() const
	{
		return reinterpret_cast<const UObject*>(this);
	}
};
static_assert(alignof(IActorSoundParameterInterface) == 0x000001, "Wrong alignment on IActorSoundParameterInterface");
static_assert(sizeof(IActorSoundParameterInterface) == 0x000001, "Wrong size on IActorSoundParameterInterface");

// Class Engine.VectorFieldVolume
// 0x0008 (0x02A8 - 0x02A0)
class AVectorFieldVolume final : public AActor
{
public:
	class UVectorFieldComponent*                  VectorFieldComponent;                              // 0x02A0(0x0008)(Edit, BlueprintVisible, ExportObject, BlueprintReadOnly, ZeroConstructor, EditConst, InstancedReference, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"VectorFieldVolume">();
	}
	static class AVectorFieldVolume* GetDefaultObj()
	{
		return GetDefaultObjImpl<AVectorFieldVolume>();
	}
};
static_assert(alignof(AVectorFieldVolume) == 0x000008, "Wrong alignment on AVectorFieldVolume");
static_assert(sizeof(AVectorFieldVolume) == 0x0002A8, "Wrong size on AVectorFieldVolume");
static_assert(offsetof(AVectorFieldVolume, VectorFieldComponent) == 0x0002A0, "Member 'AVectorFieldVolume::VectorFieldComponent' has a wrong offset!");

// Class Engine.MaterialExpressionShaderStageSwitch
// 0x0050 (0x0100 - 0x00B0)
class UMaterialExpressionShaderStageSwitch final : public UMaterialExpression
{
public:
	struct FExpressionInput                       PixelShader;                                       // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       VertexShader;                                      // 0x00D8(0x0028)(NoDestructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionShaderStageSwitch">();
	}
	static class UMaterialExpressionShaderStageSwitch* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionShaderStageSwitch>();
	}
};
static_assert(alignof(UMaterialExpressionShaderStageSwitch) == 0x000008, "Wrong alignment on UMaterialExpressionShaderStageSwitch");
static_assert(sizeof(UMaterialExpressionShaderStageSwitch) == 0x000100, "Wrong size on UMaterialExpressionShaderStageSwitch");
static_assert(offsetof(UMaterialExpressionShaderStageSwitch, PixelShader) == 0x0000B0, "Member 'UMaterialExpressionShaderStageSwitch::PixelShader' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionShaderStageSwitch, VertexShader) == 0x0000D8, "Member 'UMaterialExpressionShaderStageSwitch::VertexShader' has a wrong offset!");

// Class Engine.MaterialExpressionArctangent
// 0x0028 (0x00D8 - 0x00B0)
class UMaterialExpressionArctangent final : public UMaterialExpression
{
public:
	struct FExpressionInput                       Input;                                             // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionArctangent">();
	}
	static class UMaterialExpressionArctangent* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionArctangent>();
	}
};
static_assert(alignof(UMaterialExpressionArctangent) == 0x000008, "Wrong alignment on UMaterialExpressionArctangent");
static_assert(sizeof(UMaterialExpressionArctangent) == 0x0000D8, "Wrong size on UMaterialExpressionArctangent");
static_assert(offsetof(UMaterialExpressionArctangent, Input) == 0x0000B0, "Member 'UMaterialExpressionArctangent::Input' has a wrong offset!");

// Class Engine.MaterialExpressionArctangent2
// 0x0050 (0x0100 - 0x00B0)
class UMaterialExpressionArctangent2 final : public UMaterialExpression
{
public:
	struct FExpressionInput                       Y;                                                 // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       X;                                                 // 0x00D8(0x0028)(NoDestructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionArctangent2">();
	}
	static class UMaterialExpressionArctangent2* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionArctangent2>();
	}
};
static_assert(alignof(UMaterialExpressionArctangent2) == 0x000008, "Wrong alignment on UMaterialExpressionArctangent2");
static_assert(sizeof(UMaterialExpressionArctangent2) == 0x000100, "Wrong size on UMaterialExpressionArctangent2");
static_assert(offsetof(UMaterialExpressionArctangent2, Y) == 0x0000B0, "Member 'UMaterialExpressionArctangent2::Y' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionArctangent2, X) == 0x0000D8, "Member 'UMaterialExpressionArctangent2::X' has a wrong offset!");

// Class Engine.CameraBlockingVolume
// 0x0000 (0x02D8 - 0x02D8)
class ACameraBlockingVolume final : public AVolume
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"CameraBlockingVolume">();
	}
	static class ACameraBlockingVolume* GetDefaultObj()
	{
		return GetDefaultObjImpl<ACameraBlockingVolume>();
	}
};
static_assert(alignof(ACameraBlockingVolume) == 0x000008, "Wrong alignment on ACameraBlockingVolume");
static_assert(sizeof(ACameraBlockingVolume) == 0x0002D8, "Wrong size on ACameraBlockingVolume");

// Class Engine.MaterialExpressionHsvToRgb
// 0x0028 (0x00D8 - 0x00B0)
class UMaterialExpressionHsvToRgb final : public UMaterialExpression
{
public:
	struct FExpressionInput                       Input;                                             // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionHsvToRgb">();
	}
	static class UMaterialExpressionHsvToRgb* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionHsvToRgb>();
	}
};
static_assert(alignof(UMaterialExpressionHsvToRgb) == 0x000008, "Wrong alignment on UMaterialExpressionHsvToRgb");
static_assert(sizeof(UMaterialExpressionHsvToRgb) == 0x0000D8, "Wrong size on UMaterialExpressionHsvToRgb");
static_assert(offsetof(UMaterialExpressionHsvToRgb, Input) == 0x0000B0, "Member 'UMaterialExpressionHsvToRgb::Input' has a wrong offset!");

// Class Engine.MaterialExpressionArctangent2Fast
// 0x0050 (0x0100 - 0x00B0)
class UMaterialExpressionArctangent2Fast final : public UMaterialExpression
{
public:
	struct FExpressionInput                       Y;                                                 // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       X;                                                 // 0x00D8(0x0028)(NoDestructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionArctangent2Fast">();
	}
	static class UMaterialExpressionArctangent2Fast* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionArctangent2Fast>();
	}
};
static_assert(alignof(UMaterialExpressionArctangent2Fast) == 0x000008, "Wrong alignment on UMaterialExpressionArctangent2Fast");
static_assert(sizeof(UMaterialExpressionArctangent2Fast) == 0x000100, "Wrong size on UMaterialExpressionArctangent2Fast");
static_assert(offsetof(UMaterialExpressionArctangent2Fast, Y) == 0x0000B0, "Member 'UMaterialExpressionArctangent2Fast::Y' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionArctangent2Fast, X) == 0x0000D8, "Member 'UMaterialExpressionArctangent2Fast::X' has a wrong offset!");

// Class Engine.CollisionProfile
// 0x0138 (0x0170 - 0x0038)
class UCollisionProfile final : public UDeveloperSettings
{
public:
	TArray<struct FCollisionResponseTemplate>     Profiles;                                          // 0x0038(0x0010)(ZeroConstructor, Config, GlobalConfig, NativeAccessSpecifierPrivate)
	TArray<struct FCustomChannelSetup>            DefaultChannelResponses;                           // 0x0048(0x0010)(ZeroConstructor, Config, GlobalConfig, NativeAccessSpecifierPrivate)
	TArray<struct FCustomProfile>                 EditProfiles;                                      // 0x0058(0x0010)(ZeroConstructor, Config, GlobalConfig, NativeAccessSpecifierPrivate)
	TArray<struct FRedirector>                    ProfileRedirects;                                  // 0x0068(0x0010)(ZeroConstructor, Config, GlobalConfig, NativeAccessSpecifierPrivate)
	TArray<struct FRedirector>                    CollisionChannelRedirects;                         // 0x0078(0x0010)(ZeroConstructor, Config, GlobalConfig, NativeAccessSpecifierPrivate)
	uint8                                         Pad_88[0xE8];                                      // 0x0088(0x00E8)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"CollisionProfile">();
	}
	static class UCollisionProfile* GetDefaultObj()
	{
		return GetDefaultObjImpl<UCollisionProfile>();
	}
};
static_assert(alignof(UCollisionProfile) == 0x000008, "Wrong alignment on UCollisionProfile");
static_assert(sizeof(UCollisionProfile) == 0x000170, "Wrong size on UCollisionProfile");
static_assert(offsetof(UCollisionProfile, Profiles) == 0x000038, "Member 'UCollisionProfile::Profiles' has a wrong offset!");
static_assert(offsetof(UCollisionProfile, DefaultChannelResponses) == 0x000048, "Member 'UCollisionProfile::DefaultChannelResponses' has a wrong offset!");
static_assert(offsetof(UCollisionProfile, EditProfiles) == 0x000058, "Member 'UCollisionProfile::EditProfiles' has a wrong offset!");
static_assert(offsetof(UCollisionProfile, ProfileRedirects) == 0x000068, "Member 'UCollisionProfile::ProfileRedirects' has a wrong offset!");
static_assert(offsetof(UCollisionProfile, CollisionChannelRedirects) == 0x000078, "Member 'UCollisionProfile::CollisionChannelRedirects' has a wrong offset!");

// Class Engine.MaterialExpressionArctangentFast
// 0x0028 (0x00D8 - 0x00B0)
class UMaterialExpressionArctangentFast final : public UMaterialExpression
{
public:
	struct FExpressionInput                       Input;                                             // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionArctangentFast">();
	}
	static class UMaterialExpressionArctangentFast* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionArctangentFast>();
	}
};
static_assert(alignof(UMaterialExpressionArctangentFast) == 0x000008, "Wrong alignment on UMaterialExpressionArctangentFast");
static_assert(sizeof(UMaterialExpressionArctangentFast) == 0x0000D8, "Wrong size on UMaterialExpressionArctangentFast");
static_assert(offsetof(UMaterialExpressionArctangentFast, Input) == 0x0000B0, "Member 'UMaterialExpressionArctangentFast::Input' has a wrong offset!");

// Class Engine.RuntimeVirtualTextureVolume
// 0x0008 (0x02A8 - 0x02A0)
class ARuntimeVirtualTextureVolume final : public AActor
{
public:
	class URuntimeVirtualTextureComponent*        VirtualTextureComponent;                           // 0x02A0(0x0008)(Edit, BlueprintVisible, ExportObject, BlueprintReadOnly, ZeroConstructor, EditConst, InstancedReference, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"RuntimeVirtualTextureVolume">();
	}
	static class ARuntimeVirtualTextureVolume* GetDefaultObj()
	{
		return GetDefaultObjImpl<ARuntimeVirtualTextureVolume>();
	}
};
static_assert(alignof(ARuntimeVirtualTextureVolume) == 0x000008, "Wrong alignment on ARuntimeVirtualTextureVolume");
static_assert(sizeof(ARuntimeVirtualTextureVolume) == 0x0002A8, "Wrong size on ARuntimeVirtualTextureVolume");
static_assert(offsetof(ARuntimeVirtualTextureVolume, VirtualTextureComponent) == 0x0002A0, "Member 'ARuntimeVirtualTextureVolume::VirtualTextureComponent' has a wrong offset!");

// Class Engine.MaterialExpressionParticleMacroUV
// 0x0000 (0x00B0 - 0x00B0)
class UMaterialExpressionParticleMacroUV final : public UMaterialExpression
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionParticleMacroUV">();
	}
	static class UMaterialExpressionParticleMacroUV* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionParticleMacroUV>();
	}
};
static_assert(alignof(UMaterialExpressionParticleMacroUV) == 0x000008, "Wrong alignment on UMaterialExpressionParticleMacroUV");
static_assert(sizeof(UMaterialExpressionParticleMacroUV) == 0x0000B0, "Wrong size on UMaterialExpressionParticleMacroUV");

// Class Engine.MaterialExpressionAtmosphericFogColor
// 0x0028 (0x00D8 - 0x00B0)
class UMaterialExpressionAtmosphericFogColor final : public UMaterialExpression
{
public:
	struct FExpressionInput                       WorldPosition;                                     // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionAtmosphericFogColor">();
	}
	static class UMaterialExpressionAtmosphericFogColor* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionAtmosphericFogColor>();
	}
};
static_assert(alignof(UMaterialExpressionAtmosphericFogColor) == 0x000008, "Wrong alignment on UMaterialExpressionAtmosphericFogColor");
static_assert(sizeof(UMaterialExpressionAtmosphericFogColor) == 0x0000D8, "Wrong size on UMaterialExpressionAtmosphericFogColor");
static_assert(offsetof(UMaterialExpressionAtmosphericFogColor, WorldPosition) == 0x0000B0, "Member 'UMaterialExpressionAtmosphericFogColor::WorldPosition' has a wrong offset!");

// Class Engine.AnimNotify_PlayParticleEffect
// 0x0088 (0x00C0 - 0x0038)
class alignas(0x10) UAnimNotify_PlayParticleEffect final : public UAnimNotify
{
public:
	class UParticleSystem*                        PSTemplate;                                        // 0x0038(0x0008)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector                                LocationOffset;                                    // 0x0040(0x0018)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FRotator                               RotationOffset;                                    // 0x0058(0x0018)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
	struct FVector                                Scale;                                             // 0x0070(0x0018)(Edit, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_88[0x28];                                      // 0x0088(0x0028)(Fixing Size After Last Property [ Dumper-7 ])
	uint8                                         Attached : 1;                                      // 0x00B0(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_B1[0x3];                                       // 0x00B1(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	class FName                                   SocketName;                                        // 0x00B4(0x0008)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_BC[0x4];                                       // 0x00BC(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AnimNotify_PlayParticleEffect">();
	}
	static class UAnimNotify_PlayParticleEffect* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAnimNotify_PlayParticleEffect>();
	}
};
static_assert(alignof(UAnimNotify_PlayParticleEffect) == 0x000010, "Wrong alignment on UAnimNotify_PlayParticleEffect");
static_assert(sizeof(UAnimNotify_PlayParticleEffect) == 0x0000C0, "Wrong size on UAnimNotify_PlayParticleEffect");
static_assert(offsetof(UAnimNotify_PlayParticleEffect, PSTemplate) == 0x000038, "Member 'UAnimNotify_PlayParticleEffect::PSTemplate' has a wrong offset!");
static_assert(offsetof(UAnimNotify_PlayParticleEffect, LocationOffset) == 0x000040, "Member 'UAnimNotify_PlayParticleEffect::LocationOffset' has a wrong offset!");
static_assert(offsetof(UAnimNotify_PlayParticleEffect, RotationOffset) == 0x000058, "Member 'UAnimNotify_PlayParticleEffect::RotationOffset' has a wrong offset!");
static_assert(offsetof(UAnimNotify_PlayParticleEffect, Scale) == 0x000070, "Member 'UAnimNotify_PlayParticleEffect::Scale' has a wrong offset!");
static_assert(offsetof(UAnimNotify_PlayParticleEffect, SocketName) == 0x0000B4, "Member 'UAnimNotify_PlayParticleEffect::SocketName' has a wrong offset!");

// Class Engine.MaterialExpressionAtmosphericLightColor
// 0x0000 (0x00B0 - 0x00B0)
class UMaterialExpressionAtmosphericLightColor final : public UMaterialExpression
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionAtmosphericLightColor">();
	}
	static class UMaterialExpressionAtmosphericLightColor* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionAtmosphericLightColor>();
	}
};
static_assert(alignof(UMaterialExpressionAtmosphericLightColor) == 0x000008, "Wrong alignment on UMaterialExpressionAtmosphericLightColor");
static_assert(sizeof(UMaterialExpressionAtmosphericLightColor) == 0x0000B0, "Wrong size on UMaterialExpressionAtmosphericLightColor");

// Class Engine.MaterialExpressionAtmosphericLightVector
// 0x0000 (0x00B0 - 0x00B0)
class UMaterialExpressionAtmosphericLightVector final : public UMaterialExpression
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionAtmosphericLightVector">();
	}
	static class UMaterialExpressionAtmosphericLightVector* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionAtmosphericLightVector>();
	}
};
static_assert(alignof(UMaterialExpressionAtmosphericLightVector) == 0x000008, "Wrong alignment on UMaterialExpressionAtmosphericLightVector");
static_assert(sizeof(UMaterialExpressionAtmosphericLightVector) == 0x0000B0, "Wrong size on UMaterialExpressionAtmosphericLightVector");

// Class Engine.MaterialExpressionNormalize
// 0x0028 (0x00D8 - 0x00B0)
class UMaterialExpressionNormalize final : public UMaterialExpression
{
public:
	struct FExpressionInput                       VectorInput;                                       // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionNormalize">();
	}
	static class UMaterialExpressionNormalize* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionNormalize>();
	}
};
static_assert(alignof(UMaterialExpressionNormalize) == 0x000008, "Wrong alignment on UMaterialExpressionNormalize");
static_assert(sizeof(UMaterialExpressionNormalize) == 0x0000D8, "Wrong size on UMaterialExpressionNormalize");
static_assert(offsetof(UMaterialExpressionNormalize, VectorInput) == 0x0000B0, "Member 'UMaterialExpressionNormalize::VectorInput' has a wrong offset!");

// Class Engine.MaterialExpressionBentNormalCustomOutput
// 0x0028 (0x00D8 - 0x00B0)
class UMaterialExpressionBentNormalCustomOutput final : public UMaterialExpressionCustomOutput
{
public:
	struct FExpressionInput                       Input;                                             // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionBentNormalCustomOutput">();
	}
	static class UMaterialExpressionBentNormalCustomOutput* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionBentNormalCustomOutput>();
	}
};
static_assert(alignof(UMaterialExpressionBentNormalCustomOutput) == 0x000008, "Wrong alignment on UMaterialExpressionBentNormalCustomOutput");
static_assert(sizeof(UMaterialExpressionBentNormalCustomOutput) == 0x0000D8, "Wrong size on UMaterialExpressionBentNormalCustomOutput");
static_assert(offsetof(UMaterialExpressionBentNormalCustomOutput, Input) == 0x0000B0, "Member 'UMaterialExpressionBentNormalCustomOutput::Input' has a wrong offset!");

// Class Engine.BrushBuilder
// 0x0058 (0x0080 - 0x0028)
class UBrushBuilder final : public UObject
{
public:
	class FString                                 BitmapFilename;                                    // 0x0028(0x0010)(ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FString                                 ToolTip;                                           // 0x0038(0x0010)(ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         NotifyBadParams : 1;                               // 0x0048(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Transient, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_49[0x7];                                       // 0x0049(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<struct FVector>                        Vertices;                                          // 0x0050(0x0010)(ZeroConstructor, Protected, NativeAccessSpecifierProtected)
	TArray<struct FBuilderPoly>                   Polys;                                             // 0x0060(0x0010)(ZeroConstructor, Protected, NativeAccessSpecifierProtected)
	class FName                                   Layer;                                             // 0x0070(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         MergeCoplanars : 1;                                // 0x0078(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
	uint8                                         Pad_79[0x7];                                       // 0x0079(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"BrushBuilder">();
	}
	static class UBrushBuilder* GetDefaultObj()
	{
		return GetDefaultObjImpl<UBrushBuilder>();
	}
};
static_assert(alignof(UBrushBuilder) == 0x000008, "Wrong alignment on UBrushBuilder");
static_assert(sizeof(UBrushBuilder) == 0x000080, "Wrong size on UBrushBuilder");
static_assert(offsetof(UBrushBuilder, BitmapFilename) == 0x000028, "Member 'UBrushBuilder::BitmapFilename' has a wrong offset!");
static_assert(offsetof(UBrushBuilder, ToolTip) == 0x000038, "Member 'UBrushBuilder::ToolTip' has a wrong offset!");
static_assert(offsetof(UBrushBuilder, Vertices) == 0x000050, "Member 'UBrushBuilder::Vertices' has a wrong offset!");
static_assert(offsetof(UBrushBuilder, Polys) == 0x000060, "Member 'UBrushBuilder::Polys' has a wrong offset!");
static_assert(offsetof(UBrushBuilder, Layer) == 0x000070, "Member 'UBrushBuilder::Layer' has a wrong offset!");

// Class Engine.MaterialExpressionBlackBody
// 0x0028 (0x00D8 - 0x00B0)
class UMaterialExpressionBlackBody final : public UMaterialExpression
{
public:
	struct FExpressionInput                       Temp;                                              // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionBlackBody">();
	}
	static class UMaterialExpressionBlackBody* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionBlackBody>();
	}
};
static_assert(alignof(UMaterialExpressionBlackBody) == 0x000008, "Wrong alignment on UMaterialExpressionBlackBody");
static_assert(sizeof(UMaterialExpressionBlackBody) == 0x0000D8, "Wrong size on UMaterialExpressionBlackBody");
static_assert(offsetof(UMaterialExpressionBlackBody, Temp) == 0x0000B0, "Member 'UMaterialExpressionBlackBody::Temp' has a wrong offset!");

// Class Engine.MaterialExpressionBreakMaterialAttributes
// 0x0030 (0x00E0 - 0x00B0)
class UMaterialExpressionBreakMaterialAttributes final : public UMaterialExpression
{
public:
	struct FMaterialAttributesInput               MaterialAttributes;                                // 0x00B0(0x0030)(NoDestructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionBreakMaterialAttributes">();
	}
	static class UMaterialExpressionBreakMaterialAttributes* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionBreakMaterialAttributes>();
	}
};
static_assert(alignof(UMaterialExpressionBreakMaterialAttributes) == 0x000008, "Wrong alignment on UMaterialExpressionBreakMaterialAttributes");
static_assert(sizeof(UMaterialExpressionBreakMaterialAttributes) == 0x0000E0, "Wrong size on UMaterialExpressionBreakMaterialAttributes");
static_assert(offsetof(UMaterialExpressionBreakMaterialAttributes, MaterialAttributes) == 0x0000B0, "Member 'UMaterialExpressionBreakMaterialAttributes::MaterialAttributes' has a wrong offset!");

// Class Engine.EndpointSubmix
// 0x0018 (0x0058 - 0x0040)
class UEndpointSubmix final : public USoundSubmixBase
{
public:
	class FName                                   EndpointType;                                      // 0x0040(0x0008)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, AssetRegistrySearchable, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TSubclassOf<class UAudioEndpointSettingsBase> EndpointSettingsClass;                             // 0x0048(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UAudioEndpointSettingsBase*             EndpointSettings;                                  // 0x0050(0x0008)(Edit, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"EndpointSubmix">();
	}
	static class UEndpointSubmix* GetDefaultObj()
	{
		return GetDefaultObjImpl<UEndpointSubmix>();
	}
};
static_assert(alignof(UEndpointSubmix) == 0x000008, "Wrong alignment on UEndpointSubmix");
static_assert(sizeof(UEndpointSubmix) == 0x000058, "Wrong size on UEndpointSubmix");
static_assert(offsetof(UEndpointSubmix, EndpointType) == 0x000040, "Member 'UEndpointSubmix::EndpointType' has a wrong offset!");
static_assert(offsetof(UEndpointSubmix, EndpointSettingsClass) == 0x000048, "Member 'UEndpointSubmix::EndpointSettingsClass' has a wrong offset!");
static_assert(offsetof(UEndpointSubmix, EndpointSettings) == 0x000050, "Member 'UEndpointSubmix::EndpointSettings' has a wrong offset!");

// Class Engine.MaterialExpressionBumpOffset
// 0x0088 (0x0138 - 0x00B0)
class UMaterialExpressionBumpOffset final : public UMaterialExpression
{
public:
	struct FExpressionInput                       Coordinate;                                        // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       Height;                                            // 0x00D8(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       HeightRatioInput;                                  // 0x0100(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	float                                         HeightRatio;                                       // 0x0128(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         ReferencePlane;                                    // 0x012C(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint32                                        ConstCoordinate;                                   // 0x0130(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_134[0x4];                                      // 0x0134(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionBumpOffset">();
	}
	static class UMaterialExpressionBumpOffset* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionBumpOffset>();
	}
};
static_assert(alignof(UMaterialExpressionBumpOffset) == 0x000008, "Wrong alignment on UMaterialExpressionBumpOffset");
static_assert(sizeof(UMaterialExpressionBumpOffset) == 0x000138, "Wrong size on UMaterialExpressionBumpOffset");
static_assert(offsetof(UMaterialExpressionBumpOffset, Coordinate) == 0x0000B0, "Member 'UMaterialExpressionBumpOffset::Coordinate' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionBumpOffset, Height) == 0x0000D8, "Member 'UMaterialExpressionBumpOffset::Height' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionBumpOffset, HeightRatioInput) == 0x000100, "Member 'UMaterialExpressionBumpOffset::HeightRatioInput' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionBumpOffset, HeightRatio) == 0x000128, "Member 'UMaterialExpressionBumpOffset::HeightRatio' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionBumpOffset, ReferencePlane) == 0x00012C, "Member 'UMaterialExpressionBumpOffset::ReferencePlane' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionBumpOffset, ConstCoordinate) == 0x000130, "Member 'UMaterialExpressionBumpOffset::ConstCoordinate' has a wrong offset!");

// Class Engine.MaterialExpressionCameraPositionWS
// 0x0000 (0x00B0 - 0x00B0)
class UMaterialExpressionCameraPositionWS final : public UMaterialExpression
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionCameraPositionWS">();
	}
	static class UMaterialExpressionCameraPositionWS* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionCameraPositionWS>();
	}
};
static_assert(alignof(UMaterialExpressionCameraPositionWS) == 0x000008, "Wrong alignment on UMaterialExpressionCameraPositionWS");
static_assert(sizeof(UMaterialExpressionCameraPositionWS) == 0x0000B0, "Wrong size on UMaterialExpressionCameraPositionWS");

// Class Engine.MaterialExpressionCeil
// 0x0028 (0x00D8 - 0x00B0)
class UMaterialExpressionCeil final : public UMaterialExpression
{
public:
	struct FExpressionInput                       Input;                                             // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionCeil">();
	}
	static class UMaterialExpressionCeil* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionCeil>();
	}
};
static_assert(alignof(UMaterialExpressionCeil) == 0x000008, "Wrong alignment on UMaterialExpressionCeil");
static_assert(sizeof(UMaterialExpressionCeil) == 0x0000D8, "Wrong size on UMaterialExpressionCeil");
static_assert(offsetof(UMaterialExpressionCeil, Input) == 0x0000B0, "Member 'UMaterialExpressionCeil::Input' has a wrong offset!");

// Class Engine.MaterialExpressionClamp
// 0x0088 (0x0138 - 0x00B0)
class UMaterialExpressionClamp final : public UMaterialExpression
{
public:
	struct FExpressionInput                       Input;                                             // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       Min;                                               // 0x00D8(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       Max;                                               // 0x0100(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	EClampMode                                    ClampMode;                                         // 0x0128(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_129[0x3];                                      // 0x0129(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         MinDefault;                                        // 0x012C(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         MaxDefault;                                        // 0x0130(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_134[0x4];                                      // 0x0134(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionClamp">();
	}
	static class UMaterialExpressionClamp* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionClamp>();
	}
};
static_assert(alignof(UMaterialExpressionClamp) == 0x000008, "Wrong alignment on UMaterialExpressionClamp");
static_assert(sizeof(UMaterialExpressionClamp) == 0x000138, "Wrong size on UMaterialExpressionClamp");
static_assert(offsetof(UMaterialExpressionClamp, Input) == 0x0000B0, "Member 'UMaterialExpressionClamp::Input' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionClamp, Min) == 0x0000D8, "Member 'UMaterialExpressionClamp::Min' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionClamp, Max) == 0x000100, "Member 'UMaterialExpressionClamp::Max' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionClamp, ClampMode) == 0x000128, "Member 'UMaterialExpressionClamp::ClampMode' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionClamp, MinDefault) == 0x00012C, "Member 'UMaterialExpressionClamp::MinDefault' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionClamp, MaxDefault) == 0x000130, "Member 'UMaterialExpressionClamp::MaxDefault' has a wrong offset!");

// Class Engine.MaterialExpressionComment
// 0x0038 (0x00E8 - 0x00B0)
class UMaterialExpressionComment final : public UMaterialExpression
{
public:
	int32                                         SizeX;                                             // 0x00B0(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         SizeY;                                             // 0x00B4(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FString                                 Text;                                              // 0x00B8(0x0010)(Edit, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FLinearColor                           CommentColor;                                      // 0x00C8(0x0010)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         FontSize;                                          // 0x00D8(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bCommentBubbleVisible_InDetailsPanel : 1;          // 0x00DC(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bColorCommentBubble : 1;                           // 0x00DC(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_DD[0x3];                                       // 0x00DD(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	bool                                          bGroupMode;                                        // 0x00E0(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_E1[0x7];                                       // 0x00E1(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionComment">();
	}
	static class UMaterialExpressionComment* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionComment>();
	}
};
static_assert(alignof(UMaterialExpressionComment) == 0x000008, "Wrong alignment on UMaterialExpressionComment");
static_assert(sizeof(UMaterialExpressionComment) == 0x0000E8, "Wrong size on UMaterialExpressionComment");
static_assert(offsetof(UMaterialExpressionComment, SizeX) == 0x0000B0, "Member 'UMaterialExpressionComment::SizeX' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionComment, SizeY) == 0x0000B4, "Member 'UMaterialExpressionComment::SizeY' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionComment, Text) == 0x0000B8, "Member 'UMaterialExpressionComment::Text' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionComment, CommentColor) == 0x0000C8, "Member 'UMaterialExpressionComment::CommentColor' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionComment, FontSize) == 0x0000D8, "Member 'UMaterialExpressionComment::FontSize' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionComment, bGroupMode) == 0x0000E0, "Member 'UMaterialExpressionComment::bGroupMode' has a wrong offset!");

// Class Engine.MaterialExpressionComposite
// 0x0020 (0x00D0 - 0x00B0)
class UMaterialExpressionComposite final : public UMaterialExpression
{
public:
	class FString                                 SubgraphName;                                      // 0x00B0(0x0010)(Edit, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UMaterialExpressionPinBase*             InputExpressions;                                  // 0x00C0(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UMaterialExpressionPinBase*             OutputExpressions;                                 // 0x00C8(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionComposite">();
	}
	static class UMaterialExpressionComposite* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionComposite>();
	}
};
static_assert(alignof(UMaterialExpressionComposite) == 0x000008, "Wrong alignment on UMaterialExpressionComposite");
static_assert(sizeof(UMaterialExpressionComposite) == 0x0000D0, "Wrong size on UMaterialExpressionComposite");
static_assert(offsetof(UMaterialExpressionComposite, SubgraphName) == 0x0000B0, "Member 'UMaterialExpressionComposite::SubgraphName' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionComposite, InputExpressions) == 0x0000C0, "Member 'UMaterialExpressionComposite::InputExpressions' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionComposite, OutputExpressions) == 0x0000C8, "Member 'UMaterialExpressionComposite::OutputExpressions' has a wrong offset!");

// Class Engine.MaterialExpressionConstant2Vector
// 0x0008 (0x00B8 - 0x00B0)
class UMaterialExpressionConstant2Vector final : public UMaterialExpression
{
public:
	float                                         R;                                                 // 0x00B0(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         G;                                                 // 0x00B4(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionConstant2Vector">();
	}
	static class UMaterialExpressionConstant2Vector* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionConstant2Vector>();
	}
};
static_assert(alignof(UMaterialExpressionConstant2Vector) == 0x000008, "Wrong alignment on UMaterialExpressionConstant2Vector");
static_assert(sizeof(UMaterialExpressionConstant2Vector) == 0x0000B8, "Wrong size on UMaterialExpressionConstant2Vector");
static_assert(offsetof(UMaterialExpressionConstant2Vector, R) == 0x0000B0, "Member 'UMaterialExpressionConstant2Vector::R' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionConstant2Vector, G) == 0x0000B4, "Member 'UMaterialExpressionConstant2Vector::G' has a wrong offset!");

// Class Engine.MaterialExpressionConstant4Vector
// 0x0010 (0x00C0 - 0x00B0)
class UMaterialExpressionConstant4Vector final : public UMaterialExpression
{
public:
	struct FLinearColor                           Constant;                                          // 0x00B0(0x0010)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionConstant4Vector">();
	}
	static class UMaterialExpressionConstant4Vector* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionConstant4Vector>();
	}
};
static_assert(alignof(UMaterialExpressionConstant4Vector) == 0x000008, "Wrong alignment on UMaterialExpressionConstant4Vector");
static_assert(sizeof(UMaterialExpressionConstant4Vector) == 0x0000C0, "Wrong size on UMaterialExpressionConstant4Vector");
static_assert(offsetof(UMaterialExpressionConstant4Vector, Constant) == 0x0000B0, "Member 'UMaterialExpressionConstant4Vector::Constant' has a wrong offset!");

// Class Engine.MaterialExpressionCosine
// 0x0030 (0x00E0 - 0x00B0)
class UMaterialExpressionCosine final : public UMaterialExpression
{
public:
	struct FExpressionInput                       Input;                                             // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	float                                         Period;                                            // 0x00D8(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_DC[0x4];                                       // 0x00DC(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionCosine">();
	}
	static class UMaterialExpressionCosine* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionCosine>();
	}
};
static_assert(alignof(UMaterialExpressionCosine) == 0x000008, "Wrong alignment on UMaterialExpressionCosine");
static_assert(sizeof(UMaterialExpressionCosine) == 0x0000E0, "Wrong size on UMaterialExpressionCosine");
static_assert(offsetof(UMaterialExpressionCosine, Input) == 0x0000B0, "Member 'UMaterialExpressionCosine::Input' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionCosine, Period) == 0x0000D8, "Member 'UMaterialExpressionCosine::Period' has a wrong offset!");

// Class Engine.MaterialExpressionCustom
// 0x0068 (0x0118 - 0x00B0)
class UMaterialExpressionCustom final : public UMaterialExpression
{
public:
	class FString                                 code;                                              // 0x00B0(0x0010)(Edit, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	ECustomMaterialOutputType                     OutputType;                                        // 0x00C0(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_C1[0x7];                                       // 0x00C1(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	class FString                                 Description;                                       // 0x00C8(0x0010)(Edit, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TArray<struct FCustomInput>                   Inputs;                                            // 0x00D8(0x0010)(Edit, ZeroConstructor, NativeAccessSpecifierPublic)
	TArray<struct FCustomOutput>                  AdditionalOutputs;                                 // 0x00E8(0x0010)(Edit, ZeroConstructor, NativeAccessSpecifierPublic)
	TArray<struct FCustomDefine>                  AdditionalDefines;                                 // 0x00F8(0x0010)(Edit, ZeroConstructor, NativeAccessSpecifierPublic)
	TArray<class FString>                         IncludeFilePaths;                                  // 0x0108(0x0010)(Edit, ZeroConstructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionCustom">();
	}
	static class UMaterialExpressionCustom* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionCustom>();
	}
};
static_assert(alignof(UMaterialExpressionCustom) == 0x000008, "Wrong alignment on UMaterialExpressionCustom");
static_assert(sizeof(UMaterialExpressionCustom) == 0x000118, "Wrong size on UMaterialExpressionCustom");
static_assert(offsetof(UMaterialExpressionCustom, code) == 0x0000B0, "Member 'UMaterialExpressionCustom::code' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionCustom, OutputType) == 0x0000C0, "Member 'UMaterialExpressionCustom::OutputType' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionCustom, Description) == 0x0000C8, "Member 'UMaterialExpressionCustom::Description' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionCustom, Inputs) == 0x0000D8, "Member 'UMaterialExpressionCustom::Inputs' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionCustom, AdditionalOutputs) == 0x0000E8, "Member 'UMaterialExpressionCustom::AdditionalOutputs' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionCustom, AdditionalDefines) == 0x0000F8, "Member 'UMaterialExpressionCustom::AdditionalDefines' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionCustom, IncludeFilePaths) == 0x000108, "Member 'UMaterialExpressionCustom::IncludeFilePaths' has a wrong offset!");

// Class Engine.MaterialExpressionDBufferTexture
// 0x0030 (0x00E0 - 0x00B0)
class UMaterialExpressionDBufferTexture final : public UMaterialExpression
{
public:
	struct FExpressionInput                       Coordinates;                                       // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	EDBufferTextureId                             DBufferTextureId;                                  // 0x00D8(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_D9[0x7];                                       // 0x00D9(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionDBufferTexture">();
	}
	static class UMaterialExpressionDBufferTexture* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionDBufferTexture>();
	}
};
static_assert(alignof(UMaterialExpressionDBufferTexture) == 0x000008, "Wrong alignment on UMaterialExpressionDBufferTexture");
static_assert(sizeof(UMaterialExpressionDBufferTexture) == 0x0000E0, "Wrong size on UMaterialExpressionDBufferTexture");
static_assert(offsetof(UMaterialExpressionDBufferTexture, Coordinates) == 0x0000B0, "Member 'UMaterialExpressionDBufferTexture::Coordinates' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionDBufferTexture, DBufferTextureId) == 0x0000D8, "Member 'UMaterialExpressionDBufferTexture::DBufferTextureId' has a wrong offset!");

// Class Engine.MaterialExpressionDecalDerivative
// 0x0000 (0x00B0 - 0x00B0)
class UMaterialExpressionDecalDerivative final : public UMaterialExpression
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionDecalDerivative">();
	}
	static class UMaterialExpressionDecalDerivative* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionDecalDerivative>();
	}
};
static_assert(alignof(UMaterialExpressionDecalDerivative) == 0x000008, "Wrong alignment on UMaterialExpressionDecalDerivative");
static_assert(sizeof(UMaterialExpressionDecalDerivative) == 0x0000B0, "Wrong size on UMaterialExpressionDecalDerivative");

// Class Engine.MaterialExpressionDecalLifetimeOpacity
// 0x0000 (0x00B0 - 0x00B0)
class UMaterialExpressionDecalLifetimeOpacity final : public UMaterialExpression
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionDecalLifetimeOpacity">();
	}
	static class UMaterialExpressionDecalLifetimeOpacity* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionDecalLifetimeOpacity>();
	}
};
static_assert(alignof(UMaterialExpressionDecalLifetimeOpacity) == 0x000008, "Wrong alignment on UMaterialExpressionDecalLifetimeOpacity");
static_assert(sizeof(UMaterialExpressionDecalLifetimeOpacity) == 0x0000B0, "Wrong size on UMaterialExpressionDecalLifetimeOpacity");

// Class Engine.MaterialExpressionDecalMipmapLevel
// 0x0030 (0x00E0 - 0x00B0)
class UMaterialExpressionDecalMipmapLevel final : public UMaterialExpression
{
public:
	struct FExpressionInput                       TextureSize;                                       // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	float                                         ConstWidth;                                        // 0x00D8(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         ConstHeight;                                       // 0x00DC(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionDecalMipmapLevel">();
	}
	static class UMaterialExpressionDecalMipmapLevel* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionDecalMipmapLevel>();
	}
};
static_assert(alignof(UMaterialExpressionDecalMipmapLevel) == 0x000008, "Wrong alignment on UMaterialExpressionDecalMipmapLevel");
static_assert(sizeof(UMaterialExpressionDecalMipmapLevel) == 0x0000E0, "Wrong size on UMaterialExpressionDecalMipmapLevel");
static_assert(offsetof(UMaterialExpressionDecalMipmapLevel, TextureSize) == 0x0000B0, "Member 'UMaterialExpressionDecalMipmapLevel::TextureSize' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionDecalMipmapLevel, ConstWidth) == 0x0000D8, "Member 'UMaterialExpressionDecalMipmapLevel::ConstWidth' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionDecalMipmapLevel, ConstHeight) == 0x0000DC, "Member 'UMaterialExpressionDecalMipmapLevel::ConstHeight' has a wrong offset!");

// Class Engine.MaterialExpressionDepthFade
// 0x0058 (0x0108 - 0x00B0)
class UMaterialExpressionDepthFade final : public UMaterialExpression
{
public:
	struct FExpressionInput                       InOpacity;                                         // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       FadeDistance;                                      // 0x00D8(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	float                                         OpacityDefault;                                    // 0x0100(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         FadeDistanceDefault;                               // 0x0104(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionDepthFade">();
	}
	static class UMaterialExpressionDepthFade* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionDepthFade>();
	}
};
static_assert(alignof(UMaterialExpressionDepthFade) == 0x000008, "Wrong alignment on UMaterialExpressionDepthFade");
static_assert(sizeof(UMaterialExpressionDepthFade) == 0x000108, "Wrong size on UMaterialExpressionDepthFade");
static_assert(offsetof(UMaterialExpressionDepthFade, InOpacity) == 0x0000B0, "Member 'UMaterialExpressionDepthFade::InOpacity' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionDepthFade, FadeDistance) == 0x0000D8, "Member 'UMaterialExpressionDepthFade::FadeDistance' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionDepthFade, OpacityDefault) == 0x000100, "Member 'UMaterialExpressionDepthFade::OpacityDefault' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionDepthFade, FadeDistanceDefault) == 0x000104, "Member 'UMaterialExpressionDepthFade::FadeDistanceDefault' has a wrong offset!");

// Class Engine.MaterialExpressionDistance
// 0x0050 (0x0100 - 0x00B0)
class UMaterialExpressionDistance final : public UMaterialExpression
{
public:
	struct FExpressionInput                       A;                                                 // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       B;                                                 // 0x00D8(0x0028)(NoDestructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionDistance">();
	}
	static class UMaterialExpressionDistance* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionDistance>();
	}
};
static_assert(alignof(UMaterialExpressionDistance) == 0x000008, "Wrong alignment on UMaterialExpressionDistance");
static_assert(sizeof(UMaterialExpressionDistance) == 0x000100, "Wrong size on UMaterialExpressionDistance");
static_assert(offsetof(UMaterialExpressionDistance, A) == 0x0000B0, "Member 'UMaterialExpressionDistance::A' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionDistance, B) == 0x0000D8, "Member 'UMaterialExpressionDistance::B' has a wrong offset!");

// Class Engine.MaterialExpressionDistanceCullFade
// 0x0000 (0x00B0 - 0x00B0)
class UMaterialExpressionDistanceCullFade final : public UMaterialExpression
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionDistanceCullFade">();
	}
	static class UMaterialExpressionDistanceCullFade* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionDistanceCullFade>();
	}
};
static_assert(alignof(UMaterialExpressionDistanceCullFade) == 0x000008, "Wrong alignment on UMaterialExpressionDistanceCullFade");
static_assert(sizeof(UMaterialExpressionDistanceCullFade) == 0x0000B0, "Wrong size on UMaterialExpressionDistanceCullFade");

// Class Engine.MaterialExpressionDistanceFieldApproxAO
// 0x00B8 (0x0168 - 0x00B0)
class UMaterialExpressionDistanceFieldApproxAO final : public UMaterialExpression
{
public:
	struct FExpressionInput                       position;                                          // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       Normal;                                            // 0x00D8(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       BaseDistance;                                      // 0x0100(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	float                                         BaseDistanceDefault;                               // 0x0128(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_12C[0x4];                                      // 0x012C(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	struct FExpressionInput                       Radius;                                            // 0x0130(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	float                                         RadiusDefault;                                     // 0x0158(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint32                                        NumSteps;                                          // 0x015C(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         StepScaleDefault;                                  // 0x0160(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_164[0x4];                                      // 0x0164(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionDistanceFieldApproxAO">();
	}
	static class UMaterialExpressionDistanceFieldApproxAO* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionDistanceFieldApproxAO>();
	}
};
static_assert(alignof(UMaterialExpressionDistanceFieldApproxAO) == 0x000008, "Wrong alignment on UMaterialExpressionDistanceFieldApproxAO");
static_assert(sizeof(UMaterialExpressionDistanceFieldApproxAO) == 0x000168, "Wrong size on UMaterialExpressionDistanceFieldApproxAO");
static_assert(offsetof(UMaterialExpressionDistanceFieldApproxAO, position) == 0x0000B0, "Member 'UMaterialExpressionDistanceFieldApproxAO::position' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionDistanceFieldApproxAO, Normal) == 0x0000D8, "Member 'UMaterialExpressionDistanceFieldApproxAO::Normal' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionDistanceFieldApproxAO, BaseDistance) == 0x000100, "Member 'UMaterialExpressionDistanceFieldApproxAO::BaseDistance' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionDistanceFieldApproxAO, BaseDistanceDefault) == 0x000128, "Member 'UMaterialExpressionDistanceFieldApproxAO::BaseDistanceDefault' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionDistanceFieldApproxAO, Radius) == 0x000130, "Member 'UMaterialExpressionDistanceFieldApproxAO::Radius' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionDistanceFieldApproxAO, RadiusDefault) == 0x000158, "Member 'UMaterialExpressionDistanceFieldApproxAO::RadiusDefault' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionDistanceFieldApproxAO, NumSteps) == 0x00015C, "Member 'UMaterialExpressionDistanceFieldApproxAO::NumSteps' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionDistanceFieldApproxAO, StepScaleDefault) == 0x000160, "Member 'UMaterialExpressionDistanceFieldApproxAO::StepScaleDefault' has a wrong offset!");

// Class Engine.PackageMapClient
// 0x0328 (0x0408 - 0x00E0)
class UPackageMapClient final : public UPackageMap
{
public:
	uint8                                         Pad_E0[0x328];                                     // 0x00E0(0x0328)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"PackageMapClient">();
	}
	static class UPackageMapClient* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPackageMapClient>();
	}
};
static_assert(alignof(UPackageMapClient) == 0x000008, "Wrong alignment on UPackageMapClient");
static_assert(sizeof(UPackageMapClient) == 0x000408, "Wrong size on UPackageMapClient");

// Class Engine.MaterialExpressionDistanceFieldGradient
// 0x0028 (0x00D8 - 0x00B0)
class UMaterialExpressionDistanceFieldGradient final : public UMaterialExpression
{
public:
	struct FExpressionInput                       position;                                          // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionDistanceFieldGradient">();
	}
	static class UMaterialExpressionDistanceFieldGradient* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionDistanceFieldGradient>();
	}
};
static_assert(alignof(UMaterialExpressionDistanceFieldGradient) == 0x000008, "Wrong alignment on UMaterialExpressionDistanceFieldGradient");
static_assert(sizeof(UMaterialExpressionDistanceFieldGradient) == 0x0000D8, "Wrong size on UMaterialExpressionDistanceFieldGradient");
static_assert(offsetof(UMaterialExpressionDistanceFieldGradient, position) == 0x0000B0, "Member 'UMaterialExpressionDistanceFieldGradient::position' has a wrong offset!");

// Class Engine.MaterialExpressionDistanceFieldsRenderingSwitch
// 0x0050 (0x0100 - 0x00B0)
class UMaterialExpressionDistanceFieldsRenderingSwitch final : public UMaterialExpression
{
public:
	struct FExpressionInput                       No;                                                // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       Yes;                                               // 0x00D8(0x0028)(NoDestructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionDistanceFieldsRenderingSwitch">();
	}
	static class UMaterialExpressionDistanceFieldsRenderingSwitch* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionDistanceFieldsRenderingSwitch>();
	}
};
static_assert(alignof(UMaterialExpressionDistanceFieldsRenderingSwitch) == 0x000008, "Wrong alignment on UMaterialExpressionDistanceFieldsRenderingSwitch");
static_assert(sizeof(UMaterialExpressionDistanceFieldsRenderingSwitch) == 0x000100, "Wrong size on UMaterialExpressionDistanceFieldsRenderingSwitch");
static_assert(offsetof(UMaterialExpressionDistanceFieldsRenderingSwitch, No) == 0x0000B0, "Member 'UMaterialExpressionDistanceFieldsRenderingSwitch::No' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionDistanceFieldsRenderingSwitch, Yes) == 0x0000D8, "Member 'UMaterialExpressionDistanceFieldsRenderingSwitch::Yes' has a wrong offset!");

// Class Engine.MaterialExpressionDivide
// 0x0058 (0x0108 - 0x00B0)
class UMaterialExpressionDivide final : public UMaterialExpression
{
public:
	struct FExpressionInput                       A;                                                 // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       B;                                                 // 0x00D8(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	float                                         ConstA;                                            // 0x0100(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         ConstB;                                            // 0x0104(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionDivide">();
	}
	static class UMaterialExpressionDivide* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionDivide>();
	}
};
static_assert(alignof(UMaterialExpressionDivide) == 0x000008, "Wrong alignment on UMaterialExpressionDivide");
static_assert(sizeof(UMaterialExpressionDivide) == 0x000108, "Wrong size on UMaterialExpressionDivide");
static_assert(offsetof(UMaterialExpressionDivide, A) == 0x0000B0, "Member 'UMaterialExpressionDivide::A' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionDivide, B) == 0x0000D8, "Member 'UMaterialExpressionDivide::B' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionDivide, ConstA) == 0x000100, "Member 'UMaterialExpressionDivide::ConstA' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionDivide, ConstB) == 0x000104, "Member 'UMaterialExpressionDivide::ConstB' has a wrong offset!");

// Class Engine.MaterialExpressionDoubleVectorParameter
// 0x0028 (0x0100 - 0x00D8)
class UMaterialExpressionDoubleVectorParameter final : public UMaterialExpressionParameter
{
public:
	uint8                                         Pad_D8[0x8];                                       // 0x00D8(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	struct FVector4d                              DefaultValue;                                      // 0x00E0(0x0020)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionDoubleVectorParameter">();
	}
	static class UMaterialExpressionDoubleVectorParameter* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionDoubleVectorParameter>();
	}
};
static_assert(alignof(UMaterialExpressionDoubleVectorParameter) == 0x000010, "Wrong alignment on UMaterialExpressionDoubleVectorParameter");
static_assert(sizeof(UMaterialExpressionDoubleVectorParameter) == 0x000100, "Wrong size on UMaterialExpressionDoubleVectorParameter");
static_assert(offsetof(UMaterialExpressionDoubleVectorParameter, DefaultValue) == 0x0000E0, "Member 'UMaterialExpressionDoubleVectorParameter::DefaultValue' has a wrong offset!");

// Class Engine.MaterialExpressionExecBegin
// 0x0008 (0x00B8 - 0x00B0)
class UMaterialExpressionExecBegin final : public UMaterialExpression
{
public:
	struct FExpressionExecOutput                  Exec;                                              // 0x00B0(0x0008)(NoDestructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionExecBegin">();
	}
	static class UMaterialExpressionExecBegin* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionExecBegin>();
	}
};
static_assert(alignof(UMaterialExpressionExecBegin) == 0x000008, "Wrong alignment on UMaterialExpressionExecBegin");
static_assert(sizeof(UMaterialExpressionExecBegin) == 0x0000B8, "Wrong size on UMaterialExpressionExecBegin");
static_assert(offsetof(UMaterialExpressionExecBegin, Exec) == 0x0000B0, "Member 'UMaterialExpressionExecBegin::Exec' has a wrong offset!");

// Class Engine.SoundNodeMature
// 0x0000 (0x0048 - 0x0048)
class USoundNodeMature final : public USoundNode
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"SoundNodeMature">();
	}
	static class USoundNodeMature* GetDefaultObj()
	{
		return GetDefaultObjImpl<USoundNodeMature>();
	}
};
static_assert(alignof(USoundNodeMature) == 0x000008, "Wrong alignment on USoundNodeMature");
static_assert(sizeof(USoundNodeMature) == 0x000048, "Wrong size on USoundNodeMature");

// Class Engine.MaterialExpressionExecEnd
// 0x0000 (0x00B0 - 0x00B0)
class UMaterialExpressionExecEnd final : public UMaterialExpression
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionExecEnd">();
	}
	static class UMaterialExpressionExecEnd* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionExecEnd>();
	}
};
static_assert(alignof(UMaterialExpressionExecEnd) == 0x000008, "Wrong alignment on UMaterialExpressionExecEnd");
static_assert(sizeof(UMaterialExpressionExecEnd) == 0x0000B0, "Wrong size on UMaterialExpressionExecEnd");

// Class Engine.MaterialExpressionExponential
// 0x0028 (0x00D8 - 0x00B0)
class UMaterialExpressionExponential final : public UMaterialExpression
{
public:
	struct FExpressionInput                       Input;                                             // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionExponential">();
	}
	static class UMaterialExpressionExponential* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionExponential>();
	}
};
static_assert(alignof(UMaterialExpressionExponential) == 0x000008, "Wrong alignment on UMaterialExpressionExponential");
static_assert(sizeof(UMaterialExpressionExponential) == 0x0000D8, "Wrong size on UMaterialExpressionExponential");
static_assert(offsetof(UMaterialExpressionExponential, Input) == 0x0000B0, "Member 'UMaterialExpressionExponential::Input' has a wrong offset!");

// Class Engine.MaterialExpressionEyeAdaptation
// 0x0000 (0x00B0 - 0x00B0)
class UMaterialExpressionEyeAdaptation final : public UMaterialExpression
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionEyeAdaptation">();
	}
	static class UMaterialExpressionEyeAdaptation* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionEyeAdaptation>();
	}
};
static_assert(alignof(UMaterialExpressionEyeAdaptation) == 0x000008, "Wrong alignment on UMaterialExpressionEyeAdaptation");
static_assert(sizeof(UMaterialExpressionEyeAdaptation) == 0x0000B0, "Wrong size on UMaterialExpressionEyeAdaptation");

// Class Engine.MaterialExpressionFeatureLevelSwitch
// 0x00F0 (0x01A0 - 0x00B0)
class UMaterialExpressionFeatureLevelSwitch final : public UMaterialExpression
{
public:
	struct FExpressionInput                       Default;                                           // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       Inputs[0x5];                                       // 0x00D8(0x0028)(NoDestructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionFeatureLevelSwitch">();
	}
	static class UMaterialExpressionFeatureLevelSwitch* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionFeatureLevelSwitch>();
	}
};
static_assert(alignof(UMaterialExpressionFeatureLevelSwitch) == 0x000008, "Wrong alignment on UMaterialExpressionFeatureLevelSwitch");
static_assert(sizeof(UMaterialExpressionFeatureLevelSwitch) == 0x0001A0, "Wrong size on UMaterialExpressionFeatureLevelSwitch");
static_assert(offsetof(UMaterialExpressionFeatureLevelSwitch, Default) == 0x0000B0, "Member 'UMaterialExpressionFeatureLevelSwitch::Default' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionFeatureLevelSwitch, Inputs) == 0x0000D8, "Member 'UMaterialExpressionFeatureLevelSwitch::Inputs' has a wrong offset!");

// Class Engine.MaterialExpressionFmod
// 0x0050 (0x0100 - 0x00B0)
class UMaterialExpressionFmod final : public UMaterialExpression
{
public:
	struct FExpressionInput                       A;                                                 // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       B;                                                 // 0x00D8(0x0028)(NoDestructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionFmod">();
	}
	static class UMaterialExpressionFmod* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionFmod>();
	}
};
static_assert(alignof(UMaterialExpressionFmod) == 0x000008, "Wrong alignment on UMaterialExpressionFmod");
static_assert(sizeof(UMaterialExpressionFmod) == 0x000100, "Wrong size on UMaterialExpressionFmod");
static_assert(offsetof(UMaterialExpressionFmod, A) == 0x0000B0, "Member 'UMaterialExpressionFmod::A' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionFmod, B) == 0x0000D8, "Member 'UMaterialExpressionFmod::B' has a wrong offset!");

// Class Engine.MaterialExpressionFontSampleParameter
// 0x0028 (0x00E8 - 0x00C0)
class UMaterialExpressionFontSampleParameter final : public UMaterialExpressionFontSample
{
public:
	class FName                                   ParameterName;                                     // 0x00C0(0x0008)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FGuid                                  ExpressionGUID;                                    // 0x00C8(0x0010)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FName                                   Group;                                             // 0x00D8(0x0008)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         SortPriority;                                      // 0x00E0(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_E4[0x4];                                       // 0x00E4(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionFontSampleParameter">();
	}
	static class UMaterialExpressionFontSampleParameter* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionFontSampleParameter>();
	}
};
static_assert(alignof(UMaterialExpressionFontSampleParameter) == 0x000008, "Wrong alignment on UMaterialExpressionFontSampleParameter");
static_assert(sizeof(UMaterialExpressionFontSampleParameter) == 0x0000E8, "Wrong size on UMaterialExpressionFontSampleParameter");
static_assert(offsetof(UMaterialExpressionFontSampleParameter, ParameterName) == 0x0000C0, "Member 'UMaterialExpressionFontSampleParameter::ParameterName' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionFontSampleParameter, ExpressionGUID) == 0x0000C8, "Member 'UMaterialExpressionFontSampleParameter::ExpressionGUID' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionFontSampleParameter, Group) == 0x0000D8, "Member 'UMaterialExpressionFontSampleParameter::Group' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionFontSampleParameter, SortPriority) == 0x0000E0, "Member 'UMaterialExpressionFontSampleParameter::SortPriority' has a wrong offset!");

// Class Engine.MaterialExpressionFrac
// 0x0028 (0x00D8 - 0x00B0)
class UMaterialExpressionFrac final : public UMaterialExpression
{
public:
	struct FExpressionInput                       Input;                                             // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionFrac">();
	}
	static class UMaterialExpressionFrac* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionFrac>();
	}
};
static_assert(alignof(UMaterialExpressionFrac) == 0x000008, "Wrong alignment on UMaterialExpressionFrac");
static_assert(sizeof(UMaterialExpressionFrac) == 0x0000D8, "Wrong size on UMaterialExpressionFrac");
static_assert(offsetof(UMaterialExpressionFrac, Input) == 0x0000B0, "Member 'UMaterialExpressionFrac::Input' has a wrong offset!");

// Class Engine.MaterialExpressionFunctionInput
// 0x00B0 (0x0160 - 0x00B0)
class UMaterialExpressionFunctionInput final : public UMaterialExpression
{
public:
	struct FExpressionInput                       Preview;                                           // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	class FName                                   InputName;                                         // 0x00D8(0x0008)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FString                                 Description;                                       // 0x00E0(0x0010)(Edit, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FGuid                                  ID;                                                // 0x00F0(0x0010)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EFunctionInputType                            InputType;                                         // 0x0100(0x0001)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_101[0xF];                                      // 0x0101(0x000F)(Fixing Size After Last Property [ Dumper-7 ])
	struct FVector4f                              PreviewValue;                                      // 0x0110(0x0010)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bUsePreviewValueAsDefault : 1;                     // 0x0120(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_121[0x3];                                      // 0x0121(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	int32                                         SortPriority;                                      // 0x0124(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bCompilingFunctionPreview : 1;                     // 0x0128(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Transient, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_129[0x37];                                     // 0x0129(0x0037)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionFunctionInput">();
	}
	static class UMaterialExpressionFunctionInput* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionFunctionInput>();
	}
};
static_assert(alignof(UMaterialExpressionFunctionInput) == 0x000010, "Wrong alignment on UMaterialExpressionFunctionInput");
static_assert(sizeof(UMaterialExpressionFunctionInput) == 0x000160, "Wrong size on UMaterialExpressionFunctionInput");
static_assert(offsetof(UMaterialExpressionFunctionInput, Preview) == 0x0000B0, "Member 'UMaterialExpressionFunctionInput::Preview' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionFunctionInput, InputName) == 0x0000D8, "Member 'UMaterialExpressionFunctionInput::InputName' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionFunctionInput, Description) == 0x0000E0, "Member 'UMaterialExpressionFunctionInput::Description' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionFunctionInput, ID) == 0x0000F0, "Member 'UMaterialExpressionFunctionInput::ID' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionFunctionInput, InputType) == 0x000100, "Member 'UMaterialExpressionFunctionInput::InputType' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionFunctionInput, PreviewValue) == 0x000110, "Member 'UMaterialExpressionFunctionInput::PreviewValue' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionFunctionInput, SortPriority) == 0x000124, "Member 'UMaterialExpressionFunctionInput::SortPriority' has a wrong offset!");

// Class Engine.MaterialExpressionGetLocal
// 0x0008 (0x00B8 - 0x00B0)
class UMaterialExpressionGetLocal final : public UMaterialExpression
{
public:
	class FName                                   LocalName;                                         // 0x00B0(0x0008)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionGetLocal">();
	}
	static class UMaterialExpressionGetLocal* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionGetLocal>();
	}
};
static_assert(alignof(UMaterialExpressionGetLocal) == 0x000008, "Wrong alignment on UMaterialExpressionGetLocal");
static_assert(sizeof(UMaterialExpressionGetLocal) == 0x0000B8, "Wrong size on UMaterialExpressionGetLocal");
static_assert(offsetof(UMaterialExpressionGetLocal, LocalName) == 0x0000B0, "Member 'UMaterialExpressionGetLocal::LocalName' has a wrong offset!");

// Class Engine.MaterialExpressionGIReplace
// 0x0078 (0x0128 - 0x00B0)
class UMaterialExpressionGIReplace final : public UMaterialExpression
{
public:
	struct FExpressionInput                       Default;                                           // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       StaticIndirect;                                    // 0x00D8(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       DynamicIndirect;                                   // 0x0100(0x0028)(NoDestructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionGIReplace">();
	}
	static class UMaterialExpressionGIReplace* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionGIReplace>();
	}
};
static_assert(alignof(UMaterialExpressionGIReplace) == 0x000008, "Wrong alignment on UMaterialExpressionGIReplace");
static_assert(sizeof(UMaterialExpressionGIReplace) == 0x000128, "Wrong size on UMaterialExpressionGIReplace");
static_assert(offsetof(UMaterialExpressionGIReplace, Default) == 0x0000B0, "Member 'UMaterialExpressionGIReplace::Default' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionGIReplace, StaticIndirect) == 0x0000D8, "Member 'UMaterialExpressionGIReplace::StaticIndirect' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionGIReplace, DynamicIndirect) == 0x000100, "Member 'UMaterialExpressionGIReplace::DynamicIndirect' has a wrong offset!");

// Class Engine.MaterialExpressionHairColor
// 0x0078 (0x0128 - 0x00B0)
class UMaterialExpressionHairColor final : public UMaterialExpression
{
public:
	struct FExpressionInput                       Melanin;                                           // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       Redness;                                           // 0x00D8(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       DyeColor;                                          // 0x0100(0x0028)(NoDestructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionHairColor">();
	}
	static class UMaterialExpressionHairColor* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionHairColor>();
	}
};
static_assert(alignof(UMaterialExpressionHairColor) == 0x000008, "Wrong alignment on UMaterialExpressionHairColor");
static_assert(sizeof(UMaterialExpressionHairColor) == 0x000128, "Wrong size on UMaterialExpressionHairColor");
static_assert(offsetof(UMaterialExpressionHairColor, Melanin) == 0x0000B0, "Member 'UMaterialExpressionHairColor::Melanin' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionHairColor, Redness) == 0x0000D8, "Member 'UMaterialExpressionHairColor::Redness' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionHairColor, DyeColor) == 0x000100, "Member 'UMaterialExpressionHairColor::DyeColor' has a wrong offset!");

// Class Engine.MaterialExpressionIf
// 0x00D8 (0x0188 - 0x00B0)
class UMaterialExpressionIf final : public UMaterialExpression
{
public:
	struct FExpressionInput                       A;                                                 // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       B;                                                 // 0x00D8(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       AGreaterThanB;                                     // 0x0100(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       AEqualsB;                                          // 0x0128(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       ALessThanB;                                        // 0x0150(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	float                                         EqualsThreshold;                                   // 0x0178(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         ConstB;                                            // 0x017C(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         ConstAEqualsB;                                     // 0x0180(0x0004)(ZeroConstructor, Deprecated, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_184[0x4];                                      // 0x0184(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionIf">();
	}
	static class UMaterialExpressionIf* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionIf>();
	}
};
static_assert(alignof(UMaterialExpressionIf) == 0x000008, "Wrong alignment on UMaterialExpressionIf");
static_assert(sizeof(UMaterialExpressionIf) == 0x000188, "Wrong size on UMaterialExpressionIf");
static_assert(offsetof(UMaterialExpressionIf, A) == 0x0000B0, "Member 'UMaterialExpressionIf::A' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionIf, B) == 0x0000D8, "Member 'UMaterialExpressionIf::B' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionIf, AGreaterThanB) == 0x000100, "Member 'UMaterialExpressionIf::AGreaterThanB' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionIf, AEqualsB) == 0x000128, "Member 'UMaterialExpressionIf::AEqualsB' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionIf, ALessThanB) == 0x000150, "Member 'UMaterialExpressionIf::ALessThanB' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionIf, EqualsThreshold) == 0x000178, "Member 'UMaterialExpressionIf::EqualsThreshold' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionIf, ConstB) == 0x00017C, "Member 'UMaterialExpressionIf::ConstB' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionIf, ConstAEqualsB) == 0x000180, "Member 'UMaterialExpressionIf::ConstAEqualsB' has a wrong offset!");

// Class Engine.MaterialExpressionInverseLinearInterpolate
// 0x0088 (0x0138 - 0x00B0)
class UMaterialExpressionInverseLinearInterpolate final : public UMaterialExpression
{
public:
	struct FExpressionInput                       A;                                                 // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       B;                                                 // 0x00D8(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       Value;                                             // 0x0100(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	float                                         ConstA;                                            // 0x0128(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         ConstB;                                            // 0x012C(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         ConstValue;                                        // 0x0130(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bClampResult;                                      // 0x0134(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_135[0x3];                                      // 0x0135(0x0003)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionInverseLinearInterpolate">();
	}
	static class UMaterialExpressionInverseLinearInterpolate* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionInverseLinearInterpolate>();
	}
};
static_assert(alignof(UMaterialExpressionInverseLinearInterpolate) == 0x000008, "Wrong alignment on UMaterialExpressionInverseLinearInterpolate");
static_assert(sizeof(UMaterialExpressionInverseLinearInterpolate) == 0x000138, "Wrong size on UMaterialExpressionInverseLinearInterpolate");
static_assert(offsetof(UMaterialExpressionInverseLinearInterpolate, A) == 0x0000B0, "Member 'UMaterialExpressionInverseLinearInterpolate::A' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionInverseLinearInterpolate, B) == 0x0000D8, "Member 'UMaterialExpressionInverseLinearInterpolate::B' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionInverseLinearInterpolate, Value) == 0x000100, "Member 'UMaterialExpressionInverseLinearInterpolate::Value' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionInverseLinearInterpolate, ConstA) == 0x000128, "Member 'UMaterialExpressionInverseLinearInterpolate::ConstA' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionInverseLinearInterpolate, ConstB) == 0x00012C, "Member 'UMaterialExpressionInverseLinearInterpolate::ConstB' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionInverseLinearInterpolate, ConstValue) == 0x000130, "Member 'UMaterialExpressionInverseLinearInterpolate::ConstValue' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionInverseLinearInterpolate, bClampResult) == 0x000134, "Member 'UMaterialExpressionInverseLinearInterpolate::bClampResult' has a wrong offset!");

// Class Engine.MaterialExpressionIsOrthographic
// 0x0000 (0x00B0 - 0x00B0)
class UMaterialExpressionIsOrthographic final : public UMaterialExpression
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionIsOrthographic">();
	}
	static class UMaterialExpressionIsOrthographic* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionIsOrthographic>();
	}
};
static_assert(alignof(UMaterialExpressionIsOrthographic) == 0x000008, "Wrong alignment on UMaterialExpressionIsOrthographic");
static_assert(sizeof(UMaterialExpressionIsOrthographic) == 0x0000B0, "Wrong size on UMaterialExpressionIsOrthographic");

// Class Engine.MaterialExpressionLength
// 0x0028 (0x00D8 - 0x00B0)
class UMaterialExpressionLength final : public UMaterialExpression
{
public:
	struct FExpressionInput                       Input;                                             // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionLength">();
	}
	static class UMaterialExpressionLength* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionLength>();
	}
};
static_assert(alignof(UMaterialExpressionLength) == 0x000008, "Wrong alignment on UMaterialExpressionLength");
static_assert(sizeof(UMaterialExpressionLength) == 0x0000D8, "Wrong size on UMaterialExpressionLength");
static_assert(offsetof(UMaterialExpressionLength, Input) == 0x0000B0, "Member 'UMaterialExpressionLength::Input' has a wrong offset!");

// Class Engine.KismetSystemLibrary
// 0x0000 (0x0028 - 0x0028)
class UKismetSystemLibrary final : public UBlueprintFunctionLibrary
{
public:
	static struct FDebugFloatHistory AddFloatHistorySample(float Value, const struct FDebugFloatHistory& FloatHistory);
	static int32 BeginTransaction(const class FString& Context, const class FText& Description, class UObject* PrimaryObject);
	static bool BoxOverlapActors(const class UObject* WorldContextObject, const struct FVector& BoxPos, const struct FVector& BoxExtent, const TArray<EObjectTypeQuery>& ObjectTypes, class UClass* ActorClassFilter, const TArray<class AActor*>& ActorsToIgnore, TArray<class AActor*>* OutActors);
	static bool BoxOverlapComponents(const class UObject* WorldContextObject, const struct FVector& BoxPos, const struct FVector& Extent, const TArray<EObjectTypeQuery>& ObjectTypes, class UClass* ComponentClassFilter, const TArray<class AActor*>& ActorsToIgnore, TArray<class UPrimitiveComponent*>* OutComponents);
	static bool BoxTraceMulti(const class UObject* WorldContextObject, const struct FVector& START, const struct FVector& End, const struct FVector& HalfSize, const struct FRotator& Orientation, ETraceTypeQuery TraceChannel, bool bTraceComplex, const TArray<class AActor*>& ActorsToIgnore, EDrawDebugTrace DrawDebugType, TArray<struct FHitResult>* OutHits, bool bIgnoreSelf, const struct FLinearColor& TraceColor, const struct FLinearColor& TraceHitColor, float DrawTime);
	static bool BoxTraceMultiByProfile(const class UObject* WorldContextObject, const struct FVector& START, const struct FVector& End, const struct FVector& HalfSize, const struct FRotator& Orientation, class FName ProfileName, bool bTraceComplex, const TArray<class AActor*>& ActorsToIgnore, EDrawDebugTrace DrawDebugType, TArray<struct FHitResult>* OutHits, bool bIgnoreSelf, const struct FLinearColor& TraceColor, const struct FLinearColor& TraceHitColor, float DrawTime);
	static bool BoxTraceMultiForObjects(const class UObject* WorldContextObject, const struct FVector& START, const struct FVector& End, const struct FVector& HalfSize, const struct FRotator& Orientation, const TArray<EObjectTypeQuery>& ObjectTypes, bool bTraceComplex, const TArray<class AActor*>& ActorsToIgnore, EDrawDebugTrace DrawDebugType, TArray<struct FHitResult>* OutHits, bool bIgnoreSelf, const struct FLinearColor& TraceColor, const struct FLinearColor& TraceHitColor, float DrawTime);
	static bool BoxTraceSingle(const class UObject* WorldContextObject, const struct FVector& START, const struct FVector& End, const struct FVector& HalfSize, const struct FRotator& Orientation, ETraceTypeQuery TraceChannel, bool bTraceComplex, const TArray<class AActor*>& ActorsToIgnore, EDrawDebugTrace DrawDebugType, struct FHitResult* OutHit, bool bIgnoreSelf, const struct FLinearColor& TraceColor, const struct FLinearColor& TraceHitColor, float DrawTime);
	static bool BoxTraceSingleByProfile(const class UObject* WorldContextObject, const struct FVector& START, const struct FVector& End, const struct FVector& HalfSize, const struct FRotator& Orientation, class FName ProfileName, bool bTraceComplex, const TArray<class AActor*>& ActorsToIgnore, EDrawDebugTrace DrawDebugType, struct FHitResult* OutHit, bool bIgnoreSelf, const struct FLinearColor& TraceColor, const struct FLinearColor& TraceHitColor, float DrawTime);
	static bool BoxTraceSingleForObjects(const class UObject* WorldContextObject, const struct FVector& START, const struct FVector& End, const struct FVector& HalfSize, const struct FRotator& Orientation, const TArray<EObjectTypeQuery>& ObjectTypes, bool bTraceComplex, const TArray<class AActor*>& ActorsToIgnore, EDrawDebugTrace DrawDebugType, struct FHitResult* OutHit, bool bIgnoreSelf, const struct FLinearColor& TraceColor, const struct FLinearColor& TraceHitColor, float DrawTime);
	static void BreakARFilter(const struct FARFilter& InARFilter, TArray<class FName>* PackageNames, TArray<class FName>* PackagePaths, TArray<struct FSoftObjectPath>* SoftObjectPaths, TArray<struct FTopLevelAssetPath>* ClassPaths, TSet<struct FTopLevelAssetPath>* RecursiveClassPathsExclusionSet, TArray<class FName>* ClassNames, TSet<class FName>* RecursiveClassesExclusionSet, bool* bRecursivePaths, bool* bRecursiveClasses, bool* bIncludeOnlyOnDiskAssets);
	static void BreakSoftClassPath(const struct FSoftClassPath& InSoftClassPath, class FString* PathString);
	static void BreakSoftObjectPath(const struct FSoftObjectPath& InSoftObjectPath, class FString* PathString);
	static void BreakTopLevelAssetPath(const struct FTopLevelAssetPath& TopLevelAssetPath, class FString* PathString);
	static void CancelTransaction(const int32 Index_0);
	static bool CanLaunchURL(const class FString& URL);
	static bool CapsuleOverlapActors(const class UObject* WorldContextObject, const struct FVector& CapsulePos, float Radius, float HalfHeight, const TArray<EObjectTypeQuery>& ObjectTypes, class UClass* ActorClassFilter, const TArray<class AActor*>& ActorsToIgnore, TArray<class AActor*>* OutActors);
	static bool CapsuleOverlapComponents(const class UObject* WorldContextObject, const struct FVector& CapsulePos, float Radius, float HalfHeight, const TArray<EObjectTypeQuery>& ObjectTypes, class UClass* ComponentClassFilter, const TArray<class AActor*>& ActorsToIgnore, TArray<class UPrimitiveComponent*>* OutComponents);
	static bool CapsuleTraceMulti(const class UObject* WorldContextObject, const struct FVector& START, const struct FVector& End, float Radius, float HalfHeight, ETraceTypeQuery TraceChannel, bool bTraceComplex, const TArray<class AActor*>& ActorsToIgnore, EDrawDebugTrace DrawDebugType, TArray<struct FHitResult>* OutHits, bool bIgnoreSelf, const struct FLinearColor& TraceColor, const struct FLinearColor& TraceHitColor, float DrawTime);
	static bool CapsuleTraceMultiByProfile(const class UObject* WorldContextObject, const struct FVector& START, const struct FVector& End, float Radius, float HalfHeight, class FName ProfileName, bool bTraceComplex, const TArray<class AActor*>& ActorsToIgnore, EDrawDebugTrace DrawDebugType, TArray<struct FHitResult>* OutHits, bool bIgnoreSelf, const struct FLinearColor& TraceColor, const struct FLinearColor& TraceHitColor, float DrawTime);
	static bool CapsuleTraceMultiForObjects(const class UObject* WorldContextObject, const struct FVector& START, const struct FVector& End, float Radius, float HalfHeight, const TArray<EObjectTypeQuery>& ObjectTypes, bool bTraceComplex, const TArray<class AActor*>& ActorsToIgnore, EDrawDebugTrace DrawDebugType, TArray<struct FHitResult>* OutHits, bool bIgnoreSelf, const struct FLinearColor& TraceColor, const struct FLinearColor& TraceHitColor, float DrawTime);
	static bool CapsuleTraceSingle(const class UObject* WorldContextObject, const struct FVector& START, const struct FVector& End, float Radius, float HalfHeight, ETraceTypeQuery TraceChannel, bool bTraceComplex, const TArray<class AActor*>& ActorsToIgnore, EDrawDebugTrace DrawDebugType, struct FHitResult* OutHit, bool bIgnoreSelf, const struct FLinearColor& TraceColor, const struct FLinearColor& TraceHitColor, float DrawTime);
	static bool CapsuleTraceSingleByProfile(const class UObject* WorldContextObject, const struct FVector& START, const struct FVector& End, float Radius, float HalfHeight, class FName ProfileName, bool bTraceComplex, const TArray<class AActor*>& ActorsToIgnore, EDrawDebugTrace DrawDebugType, struct FHitResult* OutHit, bool bIgnoreSelf, const struct FLinearColor& TraceColor, const struct FLinearColor& TraceHitColor, float DrawTime);
	static bool CapsuleTraceSingleForObjects(const class UObject* WorldContextObject, const struct FVector& START, const struct FVector& End, float Radius, float HalfHeight, const TArray<EObjectTypeQuery>& ObjectTypes, bool bTraceComplex, const TArray<class AActor*>& ActorsToIgnore, EDrawDebugTrace DrawDebugType, struct FHitResult* OutHit, bool bIgnoreSelf, const struct FLinearColor& TraceColor, const struct FLinearColor& TraceHitColor, float DrawTime);
	static void CollectGarbage();
	static bool ComponentOverlapActors(class UPrimitiveComponent* Component, const struct FTransform& ComponentTransform, const TArray<EObjectTypeQuery>& ObjectTypes, class UClass* ActorClassFilter, const TArray<class AActor*>& ActorsToIgnore, TArray<class AActor*>* OutActors);
	static bool ComponentOverlapComponents(class UPrimitiveComponent* Component, const struct FTransform& ComponentTransform, const TArray<EObjectTypeQuery>& ObjectTypes, class UClass* ComponentClassFilter, const TArray<class AActor*>& ActorsToIgnore, TArray<class UPrimitiveComponent*>* OutComponents);
	static void ControlScreensaver(bool bAllowScreenSaver);
	static TSoftClassPtr<class UClass> Conv_ClassToSoftClassReference(const TSubclassOf<class UObject>& Class_0);
	static struct FSoftComponentReference Conv_ComponentReferenceToSoftComponentReference(const struct FComponentReference& ComponentReference);
	static class UObject* Conv_InterfaceToObject(const TScriptInterface<class IInterface>& Interface);
	static class UClass* Conv_ObjectToClass(class UObject* Object, TSubclassOf<class UObject> Class_0);
	static TSoftObjectPtr<class UObject> Conv_ObjectToSoftObjectReference(class UObject* Object);
	static class FString Conv_PrimaryAssetIdToString(const struct FPrimaryAssetId& PrimaryAssetId);
	static class FString Conv_PrimaryAssetTypeToString(const struct FPrimaryAssetType& PrimaryAssetType);
	static TSoftClassPtr<class UClass> Conv_SoftClassPathToSoftClassRef(const struct FSoftClassPath& SoftClassPath);
	static TSubclassOf<class UObject> Conv_SoftClassReferenceToClass(const TSoftClassPtr<class UClass>& SoftClass);
	static class FString Conv_SoftClassReferenceToString(const TSoftClassPtr<class UClass>& SoftClassReference);
	static class UObject* Conv_SoftObjectReferenceToObject(const TSoftObjectPtr<class UObject>& SoftObject);
	static class FString Conv_SoftObjectReferenceToString(const TSoftObjectPtr<class UObject>& SoftObjectReference);
	static TSoftObjectPtr<class UObject> Conv_SoftObjPathToSoftObjRef(const struct FSoftObjectPath& SoftObjectPath);
	static struct FSoftClassPath Conv_SoftObjRefToSoftClassPath(TSoftClassPtr<class UClass> SoftClassReference);
	static struct FSoftObjectPath Conv_SoftObjRefToSoftObjPath(TSoftObjectPtr<class UObject> SoftObjectReference);
	static class FString ConvertToAbsolutePath(const class FString& Filename);
	static class FString ConvertToRelativePath(const class FString& Filename);
	static void CreateCopyForUndoBuffer(class UObject* ObjectToModify);
	static void Delay(const class UObject* WorldContextObject, float Duration, const struct FLatentActionInfo& LatentInfo);
	static void DelayUntilNextTick(const class UObject* WorldContextObject, const struct FLatentActionInfo& LatentInfo);
	static bool DoesImplementInterface(const class UObject* TestObject, TSubclassOf<class IInterface> Interface);
	static void DrawDebugArrow(const class UObject* WorldContextObject, const struct FVector& LineStart, const struct FVector& LineEnd, float ArrowSize, const struct FLinearColor& LineColor, float Duration, float Thickness);
	static void DrawDebugBox(const class UObject* WorldContextObject, const struct FVector& Center, const struct FVector& Extent, const struct FLinearColor& LineColor, const struct FRotator& Rotation, float Duration, float Thickness);
	static void DrawDebugCamera(const class ACameraActor* CameraActor, const struct FLinearColor& CameraColor, float Duration);
	static void DrawDebugCapsule(const class UObject* WorldContextObject, const struct FVector& Center, float HalfHeight, float Radius, const struct FRotator& Rotation, const struct FLinearColor& LineColor, float Duration, float Thickness);
	static void DrawDebugCircle(const class UObject* WorldContextObject, const struct FVector& Center, float Radius, int32 NumSegments, const struct FLinearColor& LineColor, float Duration, float Thickness, const struct FVector& YAxis, const struct FVector& ZAxis, bool bDrawAxis);
	static void DrawDebugCone(const class UObject* WorldContextObject, const struct FVector& Origin, const struct FVector& Direction, float Length, float AngleWidth, float AngleHeight, int32 NumSides, const struct FLinearColor& LineColor, float Duration, float Thickness);
	static void DrawDebugConeInDegrees(const class UObject* WorldContextObject, const struct FVector& Origin, const struct FVector& Direction, float Length, float AngleWidth, float AngleHeight, int32 NumSides, const struct FLinearColor& LineColor, float Duration, float Thickness);
	static void DrawDebugCoordinateSystem(const class UObject* WorldContextObject, const struct FVector& AxisLoc, const struct FRotator& AxisRot, float Scale, float Duration, float Thickness);
	static void DrawDebugCylinder(const class UObject* WorldContextObject, const struct FVector& START, const struct FVector& End, float Radius, int32 Segments, const struct FLinearColor& LineColor, float Duration, float Thickness);
	static void DrawDebugFloatHistoryLocation(const class UObject* WorldContextObject, const struct FDebugFloatHistory& FloatHistory, const struct FVector& DrawLocation, const struct FVector2D& DrawSize, const struct FLinearColor& DrawColor, float Duration);
	static void DrawDebugFloatHistoryTransform(const class UObject* WorldContextObject, const struct FDebugFloatHistory& FloatHistory, const struct FTransform& DrawTransform, const struct FVector2D& DrawSize, const struct FLinearColor& DrawColor, float Duration);
	static void DrawDebugFrustum(const class UObject* WorldContextObject, const struct FTransform& FrustumTransform, const struct FLinearColor& FrustumColor, float Duration, float Thickness);
	static void DrawDebugLine(const class UObject* WorldContextObject, const struct FVector& LineStart, const struct FVector& LineEnd, const struct FLinearColor& LineColor, float Duration, float Thickness);
	static void DrawDebugPlane(const class UObject* WorldContextObject, const struct FPlane& PlaneCoordinates, const struct FVector& Location, float Size, const struct FLinearColor& PlaneColor, float Duration);
	static void DrawDebugPoint(const class UObject* WorldContextObject, const struct FVector& position, float Size, const struct FLinearColor& PointColor, float Duration);
	static void DrawDebugSphere(const class UObject* WorldContextObject, const struct FVector& Center, float Radius, int32 Segments, const struct FLinearColor& LineColor, float Duration, float Thickness);
	static void DrawDebugString(const class UObject* WorldContextObject, const struct FVector& TextLocation, const class FString& Text, class AActor* TestBaseActor, const struct FLinearColor& TextColor, float Duration);
	static int32 EndTransaction();
	static bool EqualEqual_PrimaryAssetId(const struct FPrimaryAssetId& A, const struct FPrimaryAssetId& B);
	static bool EqualEqual_PrimaryAssetType(const struct FPrimaryAssetType& A, const struct FPrimaryAssetType& B);
	static bool EqualEqual_SoftClassReference(const TSoftClassPtr<class UClass>& A, const TSoftClassPtr<class UClass>& B);
	static bool EqualEqual_SoftObjectReference(const TSoftObjectPtr<class UObject>& A, const TSoftObjectPtr<class UObject>& B);
	static void ExecuteConsoleCommand(const class UObject* WorldContextObject, const class FString& Command, class APlayerController* SpecificPlayer);
	static void FlushDebugStrings(const class UObject* WorldContextObject);
	static void FlushPersistentDebugLines(const class UObject* WorldContextObject);
	static void ForceCloseAdBanner();
	static void GetActorBounds(const class AActor* Actor, struct FVector* Origin, struct FVector* BoxExtent);
	static void GetActorListFromComponentList(const TArray<class UPrimitiveComponent*>& ComponentList, class UClass* ActorClassFilter, TArray<class AActor*>* OutActorList);
	static int32 GetAdIDCount();
	static class FString GetBuildConfiguration();
	static class FString GetBuildVersion();
	static class FString GetClassDisplayName(const class UClass* Class_0);
	static TSubclassOf<class UObject> GetClassFromPrimaryAssetId(const struct FPrimaryAssetId& PrimaryAssetId);
	static struct FTopLevelAssetPath GetClassTopLevelAssetPath(const class UClass* Class_0);
	static class FString GetCommandLine();
	static void GetComponentBounds(const class USceneComponent* Component, struct FVector* Origin, struct FVector* BoxExtent, float* SphereRadius);
	static bool GetConsoleVariableBoolValue(const class FString& VariableName);
	static float GetConsoleVariableFloatValue(const class FString& VariableName);
	static int32 GetConsoleVariableIntValue(const class FString& VariableName);
	static class FString GetConsoleVariableStringValue(const class FString& VariableName);
	static bool GetConvenientWindowedResolutions(TArray<struct FIntPoint>* Resolutions);
	static bool GetCurrentBundleState(const struct FPrimaryAssetId& PrimaryAssetId, bool bForceCurrentState, TArray<class FName>* OutBundles);
	static class FString GetDefaultLanguage();
	static class FString GetDefaultLocale();
	static class FString GetDeviceId();
	static class FString GetDisplayName(const class UObject* Object);
	static class FString GetEngineVersion();
	static struct FTopLevelAssetPath GetEnumTopLevelAssetPath(const class UEnum* Enum);
	static int64 GetFrameCount();
	static class FString GetGameBundleId();
	static class FString GetGameName();
	static class UTexture2D* GetGamepadButtonGlyph(const class FString& ButtonKey, int32 ControllerIndex);
	static class FString GetGamepadControllerName(int32 ControllerId);
	static double GetGameTimeInSeconds(const class UObject* WorldContextObject);
	static class FString GetLocalCurrencyCode();
	static class FString GetLocalCurrencySymbol();
	static int32 GetMinYResolutionFor3DView();
	static int32 GetMinYResolutionForUI();
	static class UObject* GetObjectFromPrimaryAssetId(const struct FPrimaryAssetId& PrimaryAssetId);
	static class FString GetObjectName(const class UObject* Object);
	static class UObject* GetOuterObject(const class UObject* Object);
	static class FString GetPathName(const class UObject* Object);
	static class FString GetPlatformUserDir();
	static class FString GetPlatformUserName();
	static TArray<class FString> GetPreferredLanguages();
	static struct FPrimaryAssetId GetPrimaryAssetIdFromClass(TSubclassOf<class UObject> Class_0);
	static struct FPrimaryAssetId GetPrimaryAssetIdFromObject(class UObject* Object);
	static struct FPrimaryAssetId GetPrimaryAssetIdFromSoftClassReference(TSoftClassPtr<class UClass> SoftClassReference);
	static struct FPrimaryAssetId GetPrimaryAssetIdFromSoftObjectReference(TSoftObjectPtr<class UObject> SoftObjectReference);
	static void GetPrimaryAssetIdList(const struct FPrimaryAssetType& PrimaryAssetType, TArray<struct FPrimaryAssetId>* OutPrimaryAssetIdList);
	static void GetPrimaryAssetsWithBundleState(const TArray<class FName>& RequiredBundles, const TArray<class FName>& ExcludedBundles, const TArray<struct FPrimaryAssetType>& ValidTypes, bool bForceCurrentState, TArray<struct FPrimaryAssetId>* OutPrimaryAssetIdList);
	static class FString GetProjectContentDirectory();
	static class FString GetProjectDirectory();
	static class FString GetProjectSavedDirectory();
	static int32 GetRenderingDetailMode();
	static int32 GetRenderingMaterialQualityLevel();
	static struct FSoftClassPath GetSoftClassPath(const class UClass* Class_0);
	static TSoftClassPtr<class UClass> GetSoftClassReferenceFromPrimaryAssetId(const struct FPrimaryAssetId& PrimaryAssetId);
	static struct FTopLevelAssetPath GetSoftClassTopLevelAssetPath(TSoftClassPtr<class UClass> SoftClassReference);
	static struct FSoftObjectPath GetSoftObjectPath(const class UObject* Object);
	static TSoftObjectPtr<class UObject> GetSoftObjectReferenceFromPrimaryAssetId(const struct FPrimaryAssetId& PrimaryAssetId);
	static struct FTopLevelAssetPath GetStructTopLevelAssetPath(const class UScriptStruct* Struct);
	static bool GetSupportedFullscreenResolutions(TArray<struct FIntPoint>* Resolutions);
	static class FString GetSystemPath(const class UObject* Object);
	static class FString GetUniqueDeviceId();
	static bool GetVolumeButtonsHandledBySystem();
	static bool HasMultipleLocalPlayers(const class UObject* WorldContextObject);
	static void HideAdBanner();
	static bool IsControllerAssignedToGamepad(int32 ControllerId);
	static bool IsDedicatedServer(const class UObject* WorldContextObject);
	static bool IsInterstitialAdAvailable();
	static bool IsInterstitialAdRequested();
	static bool IsLoggedIn(const class APlayerController* SpecificPlayer);
	static bool IsPackagedForDistribution();
	static bool IsScreensaverEnabled();
	static bool IsServer(const class UObject* WorldContextObject);
	static bool IsSplitScreen(const class UObject* WorldContextObject);
	static bool IsStandalone(const class UObject* WorldContextObject);
	static bool IsUnattended();
	static bool IsValid(const class UObject* Object);
	static bool IsValidClass(class UClass* Class_0);
	static bool IsValidPrimaryAssetId(const struct FPrimaryAssetId& PrimaryAssetId);
	static bool IsValidPrimaryAssetType(const struct FPrimaryAssetType& PrimaryAssetType);
	static bool IsValidSoftClassReference(const TSoftClassPtr<class UClass>& SoftClassReference);
	static bool IsValidSoftObjectReference(const TSoftObjectPtr<class UObject>& SoftObjectReference);
	static void K2_ClearAndInvalidateTimerHandle(const class UObject* WorldContextObject, struct FTimerHandle& Handle);
	static void K2_ClearTimer(class UObject* Object, const class FString& FunctionName);
	static void K2_ClearTimerDelegate(TDelegate<void()> Delegate);
	static void K2_ClearTimerHandle(const class UObject* WorldContextObject, const struct FTimerHandle& Handle);
	static float K2_GetTimerElapsedTime(class UObject* Object, const class FString& FunctionName);
	static float K2_GetTimerElapsedTimeDelegate(TDelegate<void()> Delegate);
	static float K2_GetTimerElapsedTimeHandle(const class UObject* WorldContextObject, const struct FTimerHandle& Handle);
	static float K2_GetTimerRemainingTime(class UObject* Object, const class FString& FunctionName);
	static float K2_GetTimerRemainingTimeDelegate(TDelegate<void()> Delegate);
	static float K2_GetTimerRemainingTimeHandle(const class UObject* WorldContextObject, const struct FTimerHandle& Handle);
	static struct FTimerHandle K2_InvalidateTimerHandle(struct FTimerHandle& Handle);
	static bool K2_IsTimerActive(class UObject* Object, const class FString& FunctionName);
	static bool K2_IsTimerActiveDelegate(TDelegate<void()> Delegate);
	static bool K2_IsTimerActiveHandle(const class UObject* WorldContextObject, const struct FTimerHandle& Handle);
	static bool K2_IsTimerPaused(class UObject* Object, const class FString& FunctionName);
	static bool K2_IsTimerPausedDelegate(TDelegate<void()> Delegate);
	static bool K2_IsTimerPausedHandle(const class UObject* WorldContextObject, const struct FTimerHandle& Handle);
	static bool K2_IsValidTimerHandle(const struct FTimerHandle& Handle);
	static void K2_PauseTimer(class UObject* Object, const class FString& FunctionName);
	static void K2_PauseTimerDelegate(TDelegate<void()> Delegate);
	static void K2_PauseTimerHandle(const class UObject* WorldContextObject, const struct FTimerHandle& Handle);
	static struct FTimerHandle K2_SetTimer(class UObject* Object, const class FString& FunctionName, float Time, bool bLooping, float InitialStartDelay, float InitialStartDelayVariance);
	static struct FTimerHandle K2_SetTimerDelegate(TDelegate<void()> Delegate, float Time, bool bLooping, float InitialStartDelay, float InitialStartDelayVariance);
	static struct FTimerHandle K2_SetTimerForNextTick(class UObject* Object, const class FString& FunctionName);
	static struct FTimerHandle K2_SetTimerForNextTickDelegate(TDelegate<void()> Delegate);
	static bool K2_TimerExists(class UObject* Object, const class FString& FunctionName);
	static bool K2_TimerExistsDelegate(TDelegate<void()> Delegate);
	static bool K2_TimerExistsHandle(const class UObject* WorldContextObject, const struct FTimerHandle& Handle);
	static void K2_UnPauseTimer(class UObject* Object, const class FString& FunctionName);
	static void K2_UnPauseTimerDelegate(TDelegate<void()> Delegate);
	static void K2_UnPauseTimerHandle(const class UObject* WorldContextObject, const struct FTimerHandle& Handle);
	static void LaunchURL(const class FString& URL);
	static bool LineTraceMulti(const class UObject* WorldContextObject, const struct FVector& START, const struct FVector& End, ETraceTypeQuery TraceChannel, bool bTraceComplex, const TArray<class AActor*>& ActorsToIgnore, EDrawDebugTrace DrawDebugType, TArray<struct FHitResult>* OutHits, bool bIgnoreSelf, const struct FLinearColor& TraceColor, const struct FLinearColor& TraceHitColor, float DrawTime);
	static bool LineTraceMultiByProfile(const class UObject* WorldContextObject, const struct FVector& START, const struct FVector& End, class FName ProfileName, bool bTraceComplex, const TArray<class AActor*>& ActorsToIgnore, EDrawDebugTrace DrawDebugType, TArray<struct FHitResult>* OutHits, bool bIgnoreSelf, const struct FLinearColor& TraceColor, const struct FLinearColor& TraceHitColor, float DrawTime);
	static bool LineTraceMultiForObjects(const class UObject* WorldContextObject, const struct FVector& START, const struct FVector& End, const TArray<EObjectTypeQuery>& ObjectTypes, bool bTraceComplex, const TArray<class AActor*>& ActorsToIgnore, EDrawDebugTrace DrawDebugType, TArray<struct FHitResult>* OutHits, bool bIgnoreSelf, const struct FLinearColor& TraceColor, const struct FLinearColor& TraceHitColor, float DrawTime);
	static bool LineTraceSingle(const class UObject* WorldContextObject, const struct FVector& START, const struct FVector& End, ETraceTypeQuery TraceChannel, bool bTraceComplex, const TArray<class AActor*>& ActorsToIgnore, EDrawDebugTrace DrawDebugType, struct FHitResult* OutHit, bool bIgnoreSelf, const struct FLinearColor& TraceColor, const struct FLinearColor& TraceHitColor, float DrawTime);
	static bool LineTraceSingleByProfile(const class UObject* WorldContextObject, const struct FVector& START, const struct FVector& End, class FName ProfileName, bool bTraceComplex, const TArray<class AActor*>& ActorsToIgnore, EDrawDebugTrace DrawDebugType, struct FHitResult* OutHit, bool bIgnoreSelf, const struct FLinearColor& TraceColor, const struct FLinearColor& TraceHitColor, float DrawTime);
	static bool LineTraceSingleForObjects(const class UObject* WorldContextObject, const struct FVector& START, const struct FVector& End, const TArray<EObjectTypeQuery>& ObjectTypes, bool bTraceComplex, const TArray<class AActor*>& ActorsToIgnore, EDrawDebugTrace DrawDebugType, struct FHitResult* OutHit, bool bIgnoreSelf, const struct FLinearColor& TraceColor, const struct FLinearColor& TraceHitColor, float DrawTime);
	static void LoadAsset(const class UObject* WorldContextObject, TSoftObjectPtr<class UObject> Asset, TDelegate<void(class UObject* Loaded)> OnLoaded, const struct FLatentActionInfo& LatentInfo);
	static class UObject* LoadAsset_Blocking(TSoftObjectPtr<class UObject> Asset);
	static void LoadAssetClass(const class UObject* WorldContextObject, TSoftClassPtr<class UClass> AssetClass, TDelegate<void(TSubclassOf<class UObject> Loaded)> OnLoaded, const struct FLatentActionInfo& LatentInfo);
	static class UClass* LoadClassAsset_Blocking(TSoftClassPtr<class UClass> AssetClass);
	static void LoadInterstitialAd(int32 AdIdIndex);
	static void LogString(const class FString& InString, bool bPrintToLog);
	static struct FARFilter MakeARFilter(const TArray<class FName>& PackageNames, const TArray<class FName>& PackagePaths, const TArray<struct FSoftObjectPath>& SoftObjectPaths, const TArray<struct FTopLevelAssetPath>& ClassPaths, const TSet<struct FTopLevelAssetPath>& RecursiveClassPathsExclusionSet, const TArray<class FName>& ClassNames, const TSet<class FName>& RecursiveClassesExclusionSet, const bool bRecursivePaths, const bool bRecursiveClasses, const bool bIncludeOnlyOnDiskAssets);
	static bool MakeLiteralBool(bool Value);
	static uint8 MakeLiteralByte(uint8 Value);
	static double MakeLiteralDouble(double Value);
	static int32 MakeLiteralInt(int32 Value);
	static int64 MakeLiteralInt64(int64 Value);
	static class FName MakeLiteralName(class FName Value);
	static class FString MakeLiteralString(const class FString& Value);
	static class FText MakeLiteralText(const class FText& Value);
	static struct FSoftClassPath MakeSoftClassPath(const class FString& PathString);
	static struct FSoftObjectPath MakeSoftObjectPath(const class FString& PathString);
	static struct FTopLevelAssetPath MakeTopLevelAssetPath(const class FString& PackageName, const class FString& AssetName);
	static void MoveComponentTo(class USceneComponent* Component, const struct FVector& TargetRelativeLocation, const struct FRotator& TargetRelativeRotation, bool bEaseOut, bool bEaseIn, float OverTime, bool bForceShortestRotationPath, EMoveComponentAction MoveAction, const struct FLatentActionInfo& LatentInfo);
	static class FString NormalizeFilename(const class FString& InFilename);
	static bool NotEqual_PrimaryAssetId(const struct FPrimaryAssetId& A, const struct FPrimaryAssetId& B);
	static bool NotEqual_PrimaryAssetType(const struct FPrimaryAssetType& A, const struct FPrimaryAssetType& B);
	static bool NotEqual_SoftClassReference(const TSoftClassPtr<class UClass>& A, const TSoftClassPtr<class UClass>& B);
	static bool NotEqual_SoftObjectReference(const TSoftObjectPtr<class UObject>& A, const TSoftObjectPtr<class UObject>& B);
	static void ParseCommandLine(const class FString& InCmdLine, TArray<class FString>* OutTokens, TArray<class FString>* OutSwitches, TMap<class FString, class FString>* OutParams);
	static bool ParseParam(const class FString& InString, const class FString& InParam);
	static bool ParseParamValue(const class FString& InString, const class FString& InParam, class FString* OutValue);
	static void PrintString(const class UObject* WorldContextObject, const class FString& InString, bool bPrintToScreen, bool bPrintToLog, const struct FLinearColor& TextColor, float Duration, const class FName Key);
	static void PrintText(const class UObject* WorldContextObject, const class FText& InText, bool bPrintToScreen, bool bPrintToLog, const struct FLinearColor& TextColor, float Duration, const class FName Key);
	static void PrintWarning(const class FString& InString);
	static void QuitGame(const class UObject* WorldContextObject, class APlayerController* SpecificPlayer, EQuitPreference QuitPreference, bool bIgnorePlatformRestrictions);
	static void RegisterForRemoteNotifications();
	static void ResetGamepadAssignments();
	static void ResetGamepadAssignmentToController(int32 ControllerId);
	static void RetriggerableDelay(const class UObject* WorldContextObject, float Duration, const struct FLatentActionInfo& LatentInfo);
	static void SetBoolPropertyByName(class UObject* Object, class FName PropertyName, bool Value);
	static void SetBytePropertyByName(class UObject* Object, class FName PropertyName, uint8 Value);
	static void SetClassPropertyByName(class UObject* Object, class FName PropertyName, TSubclassOf<class UObject> Value);
	static void SetCollisionProfileNameProperty(class UObject* Object, class FName PropertyName, const struct FCollisionProfileName& Value);
	static void SetColorPropertyByName(class UObject* Object, class FName PropertyName, const struct FColor& Value);
	static void SetDoublePropertyByName(class UObject* Object, class FName PropertyName, double Value);
	static void SetFieldPathPropertyByName(class UObject* Object, class FName PropertyName, const TFieldPath<class FField>& Value);
	static void SetGamepadsBlockDeviceFeedback(bool bBlock);
	static void SetInt64PropertyByName(class UObject* Object, class FName PropertyName, int64 Value);
	static void SetInterfacePropertyByName(class UObject* Object, class FName PropertyName, const TScriptInterface<class IInterface>& Value);
	static void SetIntPropertyByName(class UObject* Object, class FName PropertyName, int32 Value);
	static void SetLinearColorPropertyByName(class UObject* Object, class FName PropertyName, const struct FLinearColor& Value);
	static void SetNamePropertyByName(class UObject* Object, class FName PropertyName, const class FName& Value);
	static void SetObjectPropertyByName(class UObject* Object, class FName PropertyName, class UObject* Value);
	static void SetRotatorPropertyByName(class UObject* Object, class FName PropertyName, const struct FRotator& Value);
	static void SetSoftClassPropertyByName(class UObject* Object, class FName PropertyName, const TSoftClassPtr<class UClass>& Value);
	static void SetSoftObjectPropertyByName(class UObject* Object, class FName PropertyName, const TSoftObjectPtr<class UObject>& Value);
	static void SetStringPropertyByName(class UObject* Object, class FName PropertyName, const class FString& Value);
	static void SetStructurePropertyByName(class UObject* Object, class FName PropertyName, const struct FGenericStruct& Value);
	static void SetSuppressViewportTransitionMessage(const class UObject* WorldContextObject, bool bState);
	static void SetTextPropertyByName(class UObject* Object, class FName PropertyName, const class FText& Value);
	static void SetTransformPropertyByName(class UObject* Object, class FName PropertyName, const struct FTransform& Value);
	static void SetUserActivity(const struct FUserActivity& UserActivity);
	static void SetVector3fPropertyByName(class UObject* Object, class FName PropertyName, const struct FVector3f& Value);
	static void SetVectorPropertyByName(class UObject* Object, class FName PropertyName, const struct FVector& Value);
	static void SetVolumeButtonsHandledBySystem(bool bEnabled);
	static void SetWindowTitle(const class FText& Title);
	static void ShowAdBanner(int32 AdIdIndex, bool bShowOnBottomOfScreen);
	static void ShowInterstitialAd();
	static void ShowPlatformSpecificAchievementsScreen(const class APlayerController* SpecificPlayer);
	static void ShowPlatformSpecificLeaderboardScreen(const class FString& CategoryName);
	static void SnapshotObject(class UObject* Object);
	static bool SphereOverlapActors(const class UObject* WorldContextObject, const struct FVector& SpherePos, float SphereRadius, const TArray<EObjectTypeQuery>& ObjectTypes, class UClass* ActorClassFilter, const TArray<class AActor*>& ActorsToIgnore, TArray<class AActor*>* OutActors);
	static bool SphereOverlapComponents(const class UObject* WorldContextObject, const struct FVector& SpherePos, float SphereRadius, const TArray<EObjectTypeQuery>& ObjectTypes, class UClass* ComponentClassFilter, const TArray<class AActor*>& ActorsToIgnore, TArray<class UPrimitiveComponent*>* OutComponents);
	static bool SphereTraceMulti(const class UObject* WorldContextObject, const struct FVector& START, const struct FVector& End, float Radius, ETraceTypeQuery TraceChannel, bool bTraceComplex, const TArray<class AActor*>& ActorsToIgnore, EDrawDebugTrace DrawDebugType, TArray<struct FHitResult>* OutHits, bool bIgnoreSelf, const struct FLinearColor& TraceColor, const struct FLinearColor& TraceHitColor, float DrawTime);
	static bool SphereTraceMultiByProfile(const class UObject* WorldContextObject, const struct FVector& START, const struct FVector& End, float Radius, class FName ProfileName, bool bTraceComplex, const TArray<class AActor*>& ActorsToIgnore, EDrawDebugTrace DrawDebugType, TArray<struct FHitResult>* OutHits, bool bIgnoreSelf, const struct FLinearColor& TraceColor, const struct FLinearColor& TraceHitColor, float DrawTime);
	static bool SphereTraceMultiForObjects(const class UObject* WorldContextObject, const struct FVector& START, const struct FVector& End, float Radius, const TArray<EObjectTypeQuery>& ObjectTypes, bool bTraceComplex, const TArray<class AActor*>& ActorsToIgnore, EDrawDebugTrace DrawDebugType, TArray<struct FHitResult>* OutHits, bool bIgnoreSelf, const struct FLinearColor& TraceColor, const struct FLinearColor& TraceHitColor, float DrawTime);
	static bool SphereTraceSingle(const class UObject* WorldContextObject, const struct FVector& START, const struct FVector& End, float Radius, ETraceTypeQuery TraceChannel, bool bTraceComplex, const TArray<class AActor*>& ActorsToIgnore, EDrawDebugTrace DrawDebugType, struct FHitResult* OutHit, bool bIgnoreSelf, const struct FLinearColor& TraceColor, const struct FLinearColor& TraceHitColor, float DrawTime);
	static bool SphereTraceSingleByProfile(const class UObject* WorldContextObject, const struct FVector& START, const struct FVector& End, float Radius, class FName ProfileName, bool bTraceComplex, const TArray<class AActor*>& ActorsToIgnore, EDrawDebugTrace DrawDebugType, struct FHitResult* OutHit, bool bIgnoreSelf, const struct FLinearColor& TraceColor, const struct FLinearColor& TraceHitColor, float DrawTime);
	static bool SphereTraceSingleForObjects(const class UObject* WorldContextObject, const struct FVector& START, const struct FVector& End, float Radius, const TArray<EObjectTypeQuery>& ObjectTypes, bool bTraceComplex, const TArray<class AActor*>& ActorsToIgnore, EDrawDebugTrace DrawDebugType, struct FHitResult* OutHit, bool bIgnoreSelf, const struct FLinearColor& TraceColor, const struct FLinearColor& TraceHitColor, float DrawTime);
	static void StackTrace();
	static void TransactObject(class UObject* Object);
	static void UnloadPrimaryAsset(const struct FPrimaryAssetId& PrimaryAssetId);
	static void UnloadPrimaryAssetList(const TArray<struct FPrimaryAssetId>& PrimaryAssetIdList);
	static void UnregisterForRemoteNotifications();

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"KismetSystemLibrary">();
	}
	static class UKismetSystemLibrary* GetDefaultObj()
	{
		return GetDefaultObjImpl<UKismetSystemLibrary>();
	}
};
static_assert(alignof(UKismetSystemLibrary) == 0x000008, "Wrong alignment on UKismetSystemLibrary");
static_assert(sizeof(UKismetSystemLibrary) == 0x000028, "Wrong size on UKismetSystemLibrary");

// Class Engine.MaterialExpressionLightmassReplace
// 0x0050 (0x0100 - 0x00B0)
class UMaterialExpressionLightmassReplace final : public UMaterialExpression
{
public:
	struct FExpressionInput                       Realtime;                                          // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       Lightmass;                                         // 0x00D8(0x0028)(NoDestructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionLightmassReplace">();
	}
	static class UMaterialExpressionLightmassReplace* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionLightmassReplace>();
	}
};
static_assert(alignof(UMaterialExpressionLightmassReplace) == 0x000008, "Wrong alignment on UMaterialExpressionLightmassReplace");
static_assert(sizeof(UMaterialExpressionLightmassReplace) == 0x000100, "Wrong size on UMaterialExpressionLightmassReplace");
static_assert(offsetof(UMaterialExpressionLightmassReplace, Realtime) == 0x0000B0, "Member 'UMaterialExpressionLightmassReplace::Realtime' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionLightmassReplace, Lightmass) == 0x0000D8, "Member 'UMaterialExpressionLightmassReplace::Lightmass' has a wrong offset!");

// Class Engine.MaterialExpressionLinearInterpolate
// 0x0088 (0x0138 - 0x00B0)
class UMaterialExpressionLinearInterpolate final : public UMaterialExpression
{
public:
	struct FExpressionInput                       A;                                                 // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       B;                                                 // 0x00D8(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       Alpha;                                             // 0x0100(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	float                                         ConstA;                                            // 0x0128(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         ConstB;                                            // 0x012C(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         ConstAlpha;                                        // 0x0130(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_134[0x4];                                      // 0x0134(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionLinearInterpolate">();
	}
	static class UMaterialExpressionLinearInterpolate* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionLinearInterpolate>();
	}
};
static_assert(alignof(UMaterialExpressionLinearInterpolate) == 0x000008, "Wrong alignment on UMaterialExpressionLinearInterpolate");
static_assert(sizeof(UMaterialExpressionLinearInterpolate) == 0x000138, "Wrong size on UMaterialExpressionLinearInterpolate");
static_assert(offsetof(UMaterialExpressionLinearInterpolate, A) == 0x0000B0, "Member 'UMaterialExpressionLinearInterpolate::A' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionLinearInterpolate, B) == 0x0000D8, "Member 'UMaterialExpressionLinearInterpolate::B' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionLinearInterpolate, Alpha) == 0x000100, "Member 'UMaterialExpressionLinearInterpolate::Alpha' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionLinearInterpolate, ConstA) == 0x000128, "Member 'UMaterialExpressionLinearInterpolate::ConstA' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionLinearInterpolate, ConstB) == 0x00012C, "Member 'UMaterialExpressionLinearInterpolate::ConstB' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionLinearInterpolate, ConstAlpha) == 0x000130, "Member 'UMaterialExpressionLinearInterpolate::ConstAlpha' has a wrong offset!");

// Class Engine.BlueprintTypeConversions
// 0x0000 (0x0028 - 0x0028)
class UBlueprintTypeConversions final : public UObject
{
public:
	static TArray<int32> ConvertArrayType(const TArray<int32>& inArray);
	static int32 ConvertFBox2dToFBox2f(int32 InFromData);
	static int32 ConvertFBox2fToFBox2d(int32 InFromData);
	static int32 ConvertFMatrix44dToFMatrix44f(int32 InFromData);
	static int32 ConvertFMatrix44fToFMatrix44d(int32 InFromData);
	static int32 ConvertFPlane4dToFPlane4f(int32 InFromData);
	static int32 ConvertFPlane4fToFPlane4d(int32 InFromData);
	static int32 ConvertFQuat4dToFQuat4f(int32 InFromData);
	static int32 ConvertFQuat4fToFQuat4d(int32 InFromData);
	static int32 ConvertFRotator3dToFRotator3f(int32 InFromData);
	static int32 ConvertFRotator3fToFRotator3d(int32 InFromData);
	static int32 ConvertFTransform3dToFTransform3f(int32 InFromData);
	static int32 ConvertFTransform3fToFTransform3d(int32 InFromData);
	static int32 ConvertFVector2dToFVector2f(int32 InFromData);
	static int32 ConvertFVector2fToFVector2d(int32 InFromData);
	static int32 ConvertFVector3dToFVector3f(int32 InFromData);
	static int32 ConvertFVector3fToFVector3d(int32 InFromData);
	static int32 ConvertFVector4dToFVector4f(int32 InFromData);
	static int32 ConvertFVector4fToFVector4d(int32 InFromData);
	static TMap<int32, int32> ConvertMapType(const TMap<int32, int32>& InMap);
	static TSet<int32> ConvertSetType(const TSet<int32>& Inset);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"BlueprintTypeConversions">();
	}
	static class UBlueprintTypeConversions* GetDefaultObj()
	{
		return GetDefaultObjImpl<UBlueprintTypeConversions>();
	}
};
static_assert(alignof(UBlueprintTypeConversions) == 0x000008, "Wrong alignment on UBlueprintTypeConversions");
static_assert(sizeof(UBlueprintTypeConversions) == 0x000028, "Wrong size on UBlueprintTypeConversions");

// Class Engine.MaterialExpressionLogarithm10
// 0x0028 (0x00D8 - 0x00B0)
class UMaterialExpressionLogarithm10 final : public UMaterialExpression
{
public:
	struct FExpressionInput                       X;                                                 // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionLogarithm10">();
	}
	static class UMaterialExpressionLogarithm10* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionLogarithm10>();
	}
};
static_assert(alignof(UMaterialExpressionLogarithm10) == 0x000008, "Wrong alignment on UMaterialExpressionLogarithm10");
static_assert(sizeof(UMaterialExpressionLogarithm10) == 0x0000D8, "Wrong size on UMaterialExpressionLogarithm10");
static_assert(offsetof(UMaterialExpressionLogarithm10, X) == 0x0000B0, "Member 'UMaterialExpressionLogarithm10::X' has a wrong offset!");

// Class Engine.MaterialExpressionLogarithm2
// 0x0028 (0x00D8 - 0x00B0)
class UMaterialExpressionLogarithm2 final : public UMaterialExpression
{
public:
	struct FExpressionInput                       X;                                                 // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionLogarithm2">();
	}
	static class UMaterialExpressionLogarithm2* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionLogarithm2>();
	}
};
static_assert(alignof(UMaterialExpressionLogarithm2) == 0x000008, "Wrong alignment on UMaterialExpressionLogarithm2");
static_assert(sizeof(UMaterialExpressionLogarithm2) == 0x0000D8, "Wrong size on UMaterialExpressionLogarithm2");
static_assert(offsetof(UMaterialExpressionLogarithm2, X) == 0x0000B0, "Member 'UMaterialExpressionLogarithm2::X' has a wrong offset!");

// Class Engine.MaterialExpressionMakeMaterialAttributes
// 0x0438 (0x04E8 - 0x00B0)
class UMaterialExpressionMakeMaterialAttributes final : public UMaterialExpression
{
public:
	struct FExpressionInput                       BaseColor;                                         // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       Metallic;                                          // 0x00D8(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       Specular;                                          // 0x0100(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       Roughness;                                         // 0x0128(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       Anisotropy;                                        // 0x0150(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       EmissiveColor;                                     // 0x0178(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       Opacity;                                           // 0x01A0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       OpacityMask;                                       // 0x01C8(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       Normal;                                            // 0x01F0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       Tangent;                                           // 0x0218(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       WorldPositionOffset;                               // 0x0240(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       SubsurfaceColor;                                   // 0x0268(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       ClearCoat;                                         // 0x0290(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       ClearCoatRoughness;                                // 0x02B8(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       AmbientOcclusion;                                  // 0x02E0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       Refraction;                                        // 0x0308(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       CustomizedUVs[0x8];                                // 0x0330(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       PixelDepthOffset;                                  // 0x0470(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       ShadingModel;                                      // 0x0498(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       displacement;                                      // 0x04C0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionMakeMaterialAttributes">();
	}
	static class UMaterialExpressionMakeMaterialAttributes* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionMakeMaterialAttributes>();
	}
};
static_assert(alignof(UMaterialExpressionMakeMaterialAttributes) == 0x000008, "Wrong alignment on UMaterialExpressionMakeMaterialAttributes");
static_assert(sizeof(UMaterialExpressionMakeMaterialAttributes) == 0x0004E8, "Wrong size on UMaterialExpressionMakeMaterialAttributes");
static_assert(offsetof(UMaterialExpressionMakeMaterialAttributes, BaseColor) == 0x0000B0, "Member 'UMaterialExpressionMakeMaterialAttributes::BaseColor' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionMakeMaterialAttributes, Metallic) == 0x0000D8, "Member 'UMaterialExpressionMakeMaterialAttributes::Metallic' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionMakeMaterialAttributes, Specular) == 0x000100, "Member 'UMaterialExpressionMakeMaterialAttributes::Specular' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionMakeMaterialAttributes, Roughness) == 0x000128, "Member 'UMaterialExpressionMakeMaterialAttributes::Roughness' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionMakeMaterialAttributes, Anisotropy) == 0x000150, "Member 'UMaterialExpressionMakeMaterialAttributes::Anisotropy' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionMakeMaterialAttributes, EmissiveColor) == 0x000178, "Member 'UMaterialExpressionMakeMaterialAttributes::EmissiveColor' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionMakeMaterialAttributes, Opacity) == 0x0001A0, "Member 'UMaterialExpressionMakeMaterialAttributes::Opacity' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionMakeMaterialAttributes, OpacityMask) == 0x0001C8, "Member 'UMaterialExpressionMakeMaterialAttributes::OpacityMask' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionMakeMaterialAttributes, Normal) == 0x0001F0, "Member 'UMaterialExpressionMakeMaterialAttributes::Normal' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionMakeMaterialAttributes, Tangent) == 0x000218, "Member 'UMaterialExpressionMakeMaterialAttributes::Tangent' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionMakeMaterialAttributes, WorldPositionOffset) == 0x000240, "Member 'UMaterialExpressionMakeMaterialAttributes::WorldPositionOffset' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionMakeMaterialAttributes, SubsurfaceColor) == 0x000268, "Member 'UMaterialExpressionMakeMaterialAttributes::SubsurfaceColor' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionMakeMaterialAttributes, ClearCoat) == 0x000290, "Member 'UMaterialExpressionMakeMaterialAttributes::ClearCoat' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionMakeMaterialAttributes, ClearCoatRoughness) == 0x0002B8, "Member 'UMaterialExpressionMakeMaterialAttributes::ClearCoatRoughness' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionMakeMaterialAttributes, AmbientOcclusion) == 0x0002E0, "Member 'UMaterialExpressionMakeMaterialAttributes::AmbientOcclusion' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionMakeMaterialAttributes, Refraction) == 0x000308, "Member 'UMaterialExpressionMakeMaterialAttributes::Refraction' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionMakeMaterialAttributes, CustomizedUVs) == 0x000330, "Member 'UMaterialExpressionMakeMaterialAttributes::CustomizedUVs' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionMakeMaterialAttributes, PixelDepthOffset) == 0x000470, "Member 'UMaterialExpressionMakeMaterialAttributes::PixelDepthOffset' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionMakeMaterialAttributes, ShadingModel) == 0x000498, "Member 'UMaterialExpressionMakeMaterialAttributes::ShadingModel' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionMakeMaterialAttributes, displacement) == 0x0004C0, "Member 'UMaterialExpressionMakeMaterialAttributes::displacement' has a wrong offset!");

// Class Engine.LevelActorContainer
// 0x0010 (0x0038 - 0x0028)
class ULevelActorContainer final : public UObject
{
public:
	TArray<class AActor*>                         Actors;                                            // 0x0028(0x0010)(ZeroConstructor, Transient, UObjectWrapper, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"LevelActorContainer">();
	}
	static class ULevelActorContainer* GetDefaultObj()
	{
		return GetDefaultObjImpl<ULevelActorContainer>();
	}
};
static_assert(alignof(ULevelActorContainer) == 0x000008, "Wrong alignment on ULevelActorContainer");
static_assert(sizeof(ULevelActorContainer) == 0x000038, "Wrong size on ULevelActorContainer");
static_assert(offsetof(ULevelActorContainer, Actors) == 0x000028, "Member 'ULevelActorContainer::Actors' has a wrong offset!");

// Class Engine.TextureRenderTarget2DArray
// 0x0020 (0x01F0 - 0x01D0)
class UTextureRenderTarget2DArray final : public UTextureRenderTarget
{
public:
	int32                                         SizeX;                                             // 0x01D0(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, AssetRegistrySearchable, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         SizeY;                                             // 0x01D4(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, AssetRegistrySearchable, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         Slices;                                            // 0x01D8(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, AssetRegistrySearchable, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FLinearColor                           ClearColor;                                        // 0x01DC(0x0010)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EPixelFormat                                  OverrideFormat;                                    // 0x01EC(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bHDR : 1;                                          // 0x01ED(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, AssetRegistrySearchable, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bForceLinearGamma : 1;                             // 0x01ED(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_1EE[0x2];                                      // 0x01EE(0x0002)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"TextureRenderTarget2DArray">();
	}
	static class UTextureRenderTarget2DArray* GetDefaultObj()
	{
		return GetDefaultObjImpl<UTextureRenderTarget2DArray>();
	}
};
static_assert(alignof(UTextureRenderTarget2DArray) == 0x000010, "Wrong alignment on UTextureRenderTarget2DArray");
static_assert(sizeof(UTextureRenderTarget2DArray) == 0x0001F0, "Wrong size on UTextureRenderTarget2DArray");
static_assert(offsetof(UTextureRenderTarget2DArray, SizeX) == 0x0001D0, "Member 'UTextureRenderTarget2DArray::SizeX' has a wrong offset!");
static_assert(offsetof(UTextureRenderTarget2DArray, SizeY) == 0x0001D4, "Member 'UTextureRenderTarget2DArray::SizeY' has a wrong offset!");
static_assert(offsetof(UTextureRenderTarget2DArray, Slices) == 0x0001D8, "Member 'UTextureRenderTarget2DArray::Slices' has a wrong offset!");
static_assert(offsetof(UTextureRenderTarget2DArray, ClearColor) == 0x0001DC, "Member 'UTextureRenderTarget2DArray::ClearColor' has a wrong offset!");
static_assert(offsetof(UTextureRenderTarget2DArray, OverrideFormat) == 0x0001EC, "Member 'UTextureRenderTarget2DArray::OverrideFormat' has a wrong offset!");

// Class Engine.MaterialExpressionMapARPassthroughCameraUV
// 0x0028 (0x00D8 - 0x00B0)
class UMaterialExpressionMapARPassthroughCameraUV final : public UMaterialExpression
{
public:
	struct FExpressionInput                       Coordinates;                                       // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionMapARPassthroughCameraUV">();
	}
	static class UMaterialExpressionMapARPassthroughCameraUV* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionMapARPassthroughCameraUV>();
	}
};
static_assert(alignof(UMaterialExpressionMapARPassthroughCameraUV) == 0x000008, "Wrong alignment on UMaterialExpressionMapARPassthroughCameraUV");
static_assert(sizeof(UMaterialExpressionMapARPassthroughCameraUV) == 0x0000D8, "Wrong size on UMaterialExpressionMapARPassthroughCameraUV");
static_assert(offsetof(UMaterialExpressionMapARPassthroughCameraUV, Coordinates) == 0x0000B0, "Member 'UMaterialExpressionMapARPassthroughCameraUV::Coordinates' has a wrong offset!");

// Class Engine.MaterialExpressionMaterialAttributeLayers
// 0x0168 (0x0218 - 0x00B0)
class UMaterialExpressionMaterialAttributeLayers final : public UMaterialExpression
{
public:
	struct FMaterialAttributesInput               Input;                                             // 0x00B0(0x0030)(NoDestructor, NativeAccessSpecifierPublic)
	struct FMaterialLayersFunctions               DefaultLayers;                                     // 0x00E0(0x0100)(Edit, NativeAccessSpecifierPublic)
	TArray<class UMaterialExpressionMaterialFunctionCall*> LayerCallers;                             // 0x01E0(0x0010)(ZeroConstructor, Transient, UObjectWrapper, NativeAccessSpecifierPublic)
	int32                                         NumActiveLayerCallers;                             // 0x01F0(0x0004)(ZeroConstructor, Transient, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1F4[0x4];                                      // 0x01F4(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<class UMaterialExpressionMaterialFunctionCall*> BlendCallers;                             // 0x01F8(0x0010)(ZeroConstructor, Transient, UObjectWrapper, NativeAccessSpecifierPublic)
	int32                                         NumActiveBlendCallers;                             // 0x0208(0x0004)(ZeroConstructor, Transient, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bIsLayerGraphBuilt;                                // 0x020C(0x0001)(ZeroConstructor, Transient, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_20D[0xB];                                      // 0x020D(0x000B)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionMaterialAttributeLayers">();
	}
	static class UMaterialExpressionMaterialAttributeLayers* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionMaterialAttributeLayers>();
	}
};
static_assert(alignof(UMaterialExpressionMaterialAttributeLayers) == 0x000008, "Wrong alignment on UMaterialExpressionMaterialAttributeLayers");
static_assert(sizeof(UMaterialExpressionMaterialAttributeLayers) == 0x000218, "Wrong size on UMaterialExpressionMaterialAttributeLayers");
static_assert(offsetof(UMaterialExpressionMaterialAttributeLayers, Input) == 0x0000B0, "Member 'UMaterialExpressionMaterialAttributeLayers::Input' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionMaterialAttributeLayers, DefaultLayers) == 0x0000E0, "Member 'UMaterialExpressionMaterialAttributeLayers::DefaultLayers' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionMaterialAttributeLayers, LayerCallers) == 0x0001E0, "Member 'UMaterialExpressionMaterialAttributeLayers::LayerCallers' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionMaterialAttributeLayers, NumActiveLayerCallers) == 0x0001F0, "Member 'UMaterialExpressionMaterialAttributeLayers::NumActiveLayerCallers' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionMaterialAttributeLayers, BlendCallers) == 0x0001F8, "Member 'UMaterialExpressionMaterialAttributeLayers::BlendCallers' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionMaterialAttributeLayers, NumActiveBlendCallers) == 0x000208, "Member 'UMaterialExpressionMaterialAttributeLayers::NumActiveBlendCallers' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionMaterialAttributeLayers, bIsLayerGraphBuilt) == 0x00020C, "Member 'UMaterialExpressionMaterialAttributeLayers::bIsLayerGraphBuilt' has a wrong offset!");

// Class Engine.MaterialExpressionMaterialLayerOutput
// 0x0000 (0x0110 - 0x0110)
class UMaterialExpressionMaterialLayerOutput final : public UMaterialExpressionFunctionOutput
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionMaterialLayerOutput">();
	}
	static class UMaterialExpressionMaterialLayerOutput* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionMaterialLayerOutput>();
	}
};
static_assert(alignof(UMaterialExpressionMaterialLayerOutput) == 0x000008, "Wrong alignment on UMaterialExpressionMaterialLayerOutput");
static_assert(sizeof(UMaterialExpressionMaterialLayerOutput) == 0x000110, "Wrong size on UMaterialExpressionMaterialLayerOutput");

// Class Engine.LevelInstanceEditorInstanceActor
// 0x0000 (0x02A0 - 0x02A0)
class ALevelInstanceEditorInstanceActor final : public AActor
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"LevelInstanceEditorInstanceActor">();
	}
	static class ALevelInstanceEditorInstanceActor* GetDefaultObj()
	{
		return GetDefaultObjImpl<ALevelInstanceEditorInstanceActor>();
	}
};
static_assert(alignof(ALevelInstanceEditorInstanceActor) == 0x000008, "Wrong alignment on ALevelInstanceEditorInstanceActor");
static_assert(sizeof(ALevelInstanceEditorInstanceActor) == 0x0002A0, "Wrong size on ALevelInstanceEditorInstanceActor");

// Class Engine.MaterialExpressionMax
// 0x0058 (0x0108 - 0x00B0)
class UMaterialExpressionMax final : public UMaterialExpression
{
public:
	struct FExpressionInput                       A;                                                 // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       B;                                                 // 0x00D8(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	float                                         ConstA;                                            // 0x0100(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         ConstB;                                            // 0x0104(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionMax">();
	}
	static class UMaterialExpressionMax* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionMax>();
	}
};
static_assert(alignof(UMaterialExpressionMax) == 0x000008, "Wrong alignment on UMaterialExpressionMax");
static_assert(sizeof(UMaterialExpressionMax) == 0x000108, "Wrong size on UMaterialExpressionMax");
static_assert(offsetof(UMaterialExpressionMax, A) == 0x0000B0, "Member 'UMaterialExpressionMax::A' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionMax, B) == 0x0000D8, "Member 'UMaterialExpressionMax::B' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionMax, ConstA) == 0x000100, "Member 'UMaterialExpressionMax::ConstA' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionMax, ConstB) == 0x000104, "Member 'UMaterialExpressionMax::ConstB' has a wrong offset!");

// Class Engine.MaterialExpressionMin
// 0x0058 (0x0108 - 0x00B0)
class UMaterialExpressionMin final : public UMaterialExpression
{
public:
	struct FExpressionInput                       A;                                                 // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       B;                                                 // 0x00D8(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	float                                         ConstA;                                            // 0x0100(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         ConstB;                                            // 0x0104(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionMin">();
	}
	static class UMaterialExpressionMin* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionMin>();
	}
};
static_assert(alignof(UMaterialExpressionMin) == 0x000008, "Wrong alignment on UMaterialExpressionMin");
static_assert(sizeof(UMaterialExpressionMin) == 0x000108, "Wrong size on UMaterialExpressionMin");
static_assert(offsetof(UMaterialExpressionMin, A) == 0x0000B0, "Member 'UMaterialExpressionMin::A' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionMin, B) == 0x0000D8, "Member 'UMaterialExpressionMin::B' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionMin, ConstA) == 0x000100, "Member 'UMaterialExpressionMin::ConstA' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionMin, ConstB) == 0x000104, "Member 'UMaterialExpressionMin::ConstB' has a wrong offset!");

// Class Engine.MaterialExpressionMultiply
// 0x0058 (0x0108 - 0x00B0)
class UMaterialExpressionMultiply final : public UMaterialExpression
{
public:
	struct FExpressionInput                       A;                                                 // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       B;                                                 // 0x00D8(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	float                                         ConstA;                                            // 0x0100(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         ConstB;                                            // 0x0104(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionMultiply">();
	}
	static class UMaterialExpressionMultiply* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionMultiply>();
	}
};
static_assert(alignof(UMaterialExpressionMultiply) == 0x000008, "Wrong alignment on UMaterialExpressionMultiply");
static_assert(sizeof(UMaterialExpressionMultiply) == 0x000108, "Wrong size on UMaterialExpressionMultiply");
static_assert(offsetof(UMaterialExpressionMultiply, A) == 0x0000B0, "Member 'UMaterialExpressionMultiply::A' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionMultiply, B) == 0x0000D8, "Member 'UMaterialExpressionMultiply::B' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionMultiply, ConstA) == 0x000100, "Member 'UMaterialExpressionMultiply::ConstA' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionMultiply, ConstB) == 0x000104, "Member 'UMaterialExpressionMultiply::ConstB' has a wrong offset!");

// Class Engine.MaterialExpressionNamedRerouteUsage
// 0x0018 (0x00C8 - 0x00B0)
class UMaterialExpressionNamedRerouteUsage final : public UMaterialExpressionNamedRerouteBase
{
public:
	class UMaterialExpressionNamedRerouteDeclaration* Declaration;                                   // 0x00B0(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FGuid                                  DeclarationGuid;                                   // 0x00B8(0x0010)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionNamedRerouteUsage">();
	}
	static class UMaterialExpressionNamedRerouteUsage* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionNamedRerouteUsage>();
	}
};
static_assert(alignof(UMaterialExpressionNamedRerouteUsage) == 0x000008, "Wrong alignment on UMaterialExpressionNamedRerouteUsage");
static_assert(sizeof(UMaterialExpressionNamedRerouteUsage) == 0x0000C8, "Wrong size on UMaterialExpressionNamedRerouteUsage");
static_assert(offsetof(UMaterialExpressionNamedRerouteUsage, Declaration) == 0x0000B0, "Member 'UMaterialExpressionNamedRerouteUsage::Declaration' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionNamedRerouteUsage, DeclarationGuid) == 0x0000B8, "Member 'UMaterialExpressionNamedRerouteUsage::DeclarationGuid' has a wrong offset!");

// Class Engine.MaterialExpressionNoise
// 0x0078 (0x0128 - 0x00B0)
class UMaterialExpressionNoise final : public UMaterialExpression
{
public:
	struct FExpressionInput                       position;                                          // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       FilterWidth;                                       // 0x00D8(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	float                                         Scale;                                             // 0x0100(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         Quality;                                           // 0x0104(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	ENoiseFunction                                NoiseFunction;                                     // 0x0108(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_109[0x3];                                      // 0x0109(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	uint8                                         bTurbulence : 1;                                   // 0x010C(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_10D[0x3];                                      // 0x010D(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	int32                                         Levels;                                            // 0x0110(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         OutputMin;                                         // 0x0114(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         OutputMax;                                         // 0x0118(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         LevelScale;                                        // 0x011C(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bTiling : 1;                                       // 0x0120(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_121[0x3];                                      // 0x0121(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	uint32                                        RepeatSize;                                        // 0x0124(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionNoise">();
	}
	static class UMaterialExpressionNoise* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionNoise>();
	}
};
static_assert(alignof(UMaterialExpressionNoise) == 0x000008, "Wrong alignment on UMaterialExpressionNoise");
static_assert(sizeof(UMaterialExpressionNoise) == 0x000128, "Wrong size on UMaterialExpressionNoise");
static_assert(offsetof(UMaterialExpressionNoise, position) == 0x0000B0, "Member 'UMaterialExpressionNoise::position' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionNoise, FilterWidth) == 0x0000D8, "Member 'UMaterialExpressionNoise::FilterWidth' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionNoise, Scale) == 0x000100, "Member 'UMaterialExpressionNoise::Scale' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionNoise, Quality) == 0x000104, "Member 'UMaterialExpressionNoise::Quality' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionNoise, NoiseFunction) == 0x000108, "Member 'UMaterialExpressionNoise::NoiseFunction' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionNoise, Levels) == 0x000110, "Member 'UMaterialExpressionNoise::Levels' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionNoise, OutputMin) == 0x000114, "Member 'UMaterialExpressionNoise::OutputMin' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionNoise, OutputMax) == 0x000118, "Member 'UMaterialExpressionNoise::OutputMax' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionNoise, LevelScale) == 0x00011C, "Member 'UMaterialExpressionNoise::LevelScale' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionNoise, RepeatSize) == 0x000124, "Member 'UMaterialExpressionNoise::RepeatSize' has a wrong offset!");

// Class Engine.MaterialExpressionObjectBounds
// 0x0000 (0x00B0 - 0x00B0)
class UMaterialExpressionObjectBounds final : public UMaterialExpression
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionObjectBounds">();
	}
	static class UMaterialExpressionObjectBounds* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionObjectBounds>();
	}
};
static_assert(alignof(UMaterialExpressionObjectBounds) == 0x000008, "Wrong alignment on UMaterialExpressionObjectBounds");
static_assert(sizeof(UMaterialExpressionObjectBounds) == 0x0000B0, "Wrong size on UMaterialExpressionObjectBounds");

// Class Engine.MaterialExpressionObjectOrientation
// 0x0000 (0x00B0 - 0x00B0)
class UMaterialExpressionObjectOrientation final : public UMaterialExpression
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionObjectOrientation">();
	}
	static class UMaterialExpressionObjectOrientation* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionObjectOrientation>();
	}
};
static_assert(alignof(UMaterialExpressionObjectOrientation) == 0x000008, "Wrong alignment on UMaterialExpressionObjectOrientation");
static_assert(sizeof(UMaterialExpressionObjectOrientation) == 0x0000B0, "Wrong size on UMaterialExpressionObjectOrientation");

// Class Engine.MaterialExpressionObjectRadius
// 0x0000 (0x00B0 - 0x00B0)
class UMaterialExpressionObjectRadius final : public UMaterialExpression
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionObjectRadius">();
	}
	static class UMaterialExpressionObjectRadius* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionObjectRadius>();
	}
};
static_assert(alignof(UMaterialExpressionObjectRadius) == 0x000008, "Wrong alignment on UMaterialExpressionObjectRadius");
static_assert(sizeof(UMaterialExpressionObjectRadius) == 0x0000B0, "Wrong size on UMaterialExpressionObjectRadius");

// Class Engine.MaterialExpressionPanner
// 0x0088 (0x0138 - 0x00B0)
class UMaterialExpressionPanner final : public UMaterialExpression
{
public:
	struct FExpressionInput                       Coordinate;                                        // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       Time;                                              // 0x00D8(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       Speed;                                             // 0x0100(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	float                                         SpeedX;                                            // 0x0128(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         SpeedY;                                            // 0x012C(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint32                                        ConstCoordinate;                                   // 0x0130(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bFractionalPart;                                   // 0x0134(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_135[0x3];                                      // 0x0135(0x0003)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionPanner">();
	}
	static class UMaterialExpressionPanner* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionPanner>();
	}
};
static_assert(alignof(UMaterialExpressionPanner) == 0x000008, "Wrong alignment on UMaterialExpressionPanner");
static_assert(sizeof(UMaterialExpressionPanner) == 0x000138, "Wrong size on UMaterialExpressionPanner");
static_assert(offsetof(UMaterialExpressionPanner, Coordinate) == 0x0000B0, "Member 'UMaterialExpressionPanner::Coordinate' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionPanner, Time) == 0x0000D8, "Member 'UMaterialExpressionPanner::Time' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionPanner, Speed) == 0x000100, "Member 'UMaterialExpressionPanner::Speed' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionPanner, SpeedX) == 0x000128, "Member 'UMaterialExpressionPanner::SpeedX' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionPanner, SpeedY) == 0x00012C, "Member 'UMaterialExpressionPanner::SpeedY' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionPanner, ConstCoordinate) == 0x000130, "Member 'UMaterialExpressionPanner::ConstCoordinate' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionPanner, bFractionalPart) == 0x000134, "Member 'UMaterialExpressionPanner::bFractionalPart' has a wrong offset!");

// Class Engine.MaterialExpressionParticleRadius
// 0x0000 (0x00B0 - 0x00B0)
class UMaterialExpressionParticleRadius final : public UMaterialExpression
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionParticleRadius">();
	}
	static class UMaterialExpressionParticleRadius* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionParticleRadius>();
	}
};
static_assert(alignof(UMaterialExpressionParticleRadius) == 0x000008, "Wrong alignment on UMaterialExpressionParticleRadius");
static_assert(sizeof(UMaterialExpressionParticleRadius) == 0x0000B0, "Wrong size on UMaterialExpressionParticleRadius");

// Class Engine.MaterialExpressionParticleRelativeTime
// 0x0000 (0x00B0 - 0x00B0)
class UMaterialExpressionParticleRelativeTime final : public UMaterialExpression
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionParticleRelativeTime">();
	}
	static class UMaterialExpressionParticleRelativeTime* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionParticleRelativeTime>();
	}
};
static_assert(alignof(UMaterialExpressionParticleRelativeTime) == 0x000008, "Wrong alignment on UMaterialExpressionParticleRelativeTime");
static_assert(sizeof(UMaterialExpressionParticleRelativeTime) == 0x0000B0, "Wrong size on UMaterialExpressionParticleRelativeTime");

// Class Engine.MaterialExpressionParticleSubUV
// 0x0008 (0x01C0 - 0x01B8)
class UMaterialExpressionParticleSubUV final : public UMaterialExpressionTextureSample
{
public:
	uint8                                         bBlend : 1;                                        // 0x01B8(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_1B9[0x7];                                      // 0x01B9(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionParticleSubUV">();
	}
	static class UMaterialExpressionParticleSubUV* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionParticleSubUV>();
	}
};
static_assert(alignof(UMaterialExpressionParticleSubUV) == 0x000008, "Wrong alignment on UMaterialExpressionParticleSubUV");
static_assert(sizeof(UMaterialExpressionParticleSubUV) == 0x0001C0, "Wrong size on UMaterialExpressionParticleSubUV");

// Class Engine.MaterialExpressionPathTracingBufferTexture
// 0x0030 (0x00E0 - 0x00B0)
class UMaterialExpressionPathTracingBufferTexture final : public UMaterialExpression
{
public:
	struct FExpressionInput                       Coordinates;                                       // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	EPathTracingBufferTextureId                   PathTracingBufferTextureId;                        // 0x00D8(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_D9[0x7];                                       // 0x00D9(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionPathTracingBufferTexture">();
	}
	static class UMaterialExpressionPathTracingBufferTexture* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionPathTracingBufferTexture>();
	}
};
static_assert(alignof(UMaterialExpressionPathTracingBufferTexture) == 0x000008, "Wrong alignment on UMaterialExpressionPathTracingBufferTexture");
static_assert(sizeof(UMaterialExpressionPathTracingBufferTexture) == 0x0000E0, "Wrong size on UMaterialExpressionPathTracingBufferTexture");
static_assert(offsetof(UMaterialExpressionPathTracingBufferTexture, Coordinates) == 0x0000B0, "Member 'UMaterialExpressionPathTracingBufferTexture::Coordinates' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionPathTracingBufferTexture, PathTracingBufferTextureId) == 0x0000D8, "Member 'UMaterialExpressionPathTracingBufferTexture::PathTracingBufferTextureId' has a wrong offset!");

// Class Engine.MaterialExpressionPathTracingRayTypeSwitch
// 0x00C8 (0x0178 - 0x00B0)
class UMaterialExpressionPathTracingRayTypeSwitch final : public UMaterialExpression
{
public:
	struct FExpressionInput                       Main;                                              // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       Shadow;                                            // 0x00D8(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       IndirectDiffuse;                                   // 0x0100(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       IndirectSpecular;                                  // 0x0128(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       IndirectVolume;                                    // 0x0150(0x0028)(NoDestructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionPathTracingRayTypeSwitch">();
	}
	static class UMaterialExpressionPathTracingRayTypeSwitch* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionPathTracingRayTypeSwitch>();
	}
};
static_assert(alignof(UMaterialExpressionPathTracingRayTypeSwitch) == 0x000008, "Wrong alignment on UMaterialExpressionPathTracingRayTypeSwitch");
static_assert(sizeof(UMaterialExpressionPathTracingRayTypeSwitch) == 0x000178, "Wrong size on UMaterialExpressionPathTracingRayTypeSwitch");
static_assert(offsetof(UMaterialExpressionPathTracingRayTypeSwitch, Main) == 0x0000B0, "Member 'UMaterialExpressionPathTracingRayTypeSwitch::Main' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionPathTracingRayTypeSwitch, Shadow) == 0x0000D8, "Member 'UMaterialExpressionPathTracingRayTypeSwitch::Shadow' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionPathTracingRayTypeSwitch, IndirectDiffuse) == 0x000100, "Member 'UMaterialExpressionPathTracingRayTypeSwitch::IndirectDiffuse' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionPathTracingRayTypeSwitch, IndirectSpecular) == 0x000128, "Member 'UMaterialExpressionPathTracingRayTypeSwitch::IndirectSpecular' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionPathTracingRayTypeSwitch, IndirectVolume) == 0x000150, "Member 'UMaterialExpressionPathTracingRayTypeSwitch::IndirectVolume' has a wrong offset!");

// Class Engine.MaterialExpressionPerInstanceCustomData3Vector
// 0x0040 (0x00F0 - 0x00B0)
class UMaterialExpressionPerInstanceCustomData3Vector final : public UMaterialExpression
{
public:
	struct FExpressionInput                       DefaultValue;                                      // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FLinearColor                           ConstDefaultValue;                                 // 0x00D8(0x0010)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint32                                        DataIndex;                                         // 0x00E8(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_EC[0x4];                                       // 0x00EC(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionPerInstanceCustomData3Vector">();
	}
	static class UMaterialExpressionPerInstanceCustomData3Vector* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionPerInstanceCustomData3Vector>();
	}
};
static_assert(alignof(UMaterialExpressionPerInstanceCustomData3Vector) == 0x000008, "Wrong alignment on UMaterialExpressionPerInstanceCustomData3Vector");
static_assert(sizeof(UMaterialExpressionPerInstanceCustomData3Vector) == 0x0000F0, "Wrong size on UMaterialExpressionPerInstanceCustomData3Vector");
static_assert(offsetof(UMaterialExpressionPerInstanceCustomData3Vector, DefaultValue) == 0x0000B0, "Member 'UMaterialExpressionPerInstanceCustomData3Vector::DefaultValue' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionPerInstanceCustomData3Vector, ConstDefaultValue) == 0x0000D8, "Member 'UMaterialExpressionPerInstanceCustomData3Vector::ConstDefaultValue' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionPerInstanceCustomData3Vector, DataIndex) == 0x0000E8, "Member 'UMaterialExpressionPerInstanceCustomData3Vector::DataIndex' has a wrong offset!");

// Class Engine.InstancedPlacemenClientSettings
// 0x0000 (0x0028 - 0x0028)
class UInstancedPlacemenClientSettings final : public UObject
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"InstancedPlacemenClientSettings">();
	}
	static class UInstancedPlacemenClientSettings* GetDefaultObj()
	{
		return GetDefaultObjImpl<UInstancedPlacemenClientSettings>();
	}
};
static_assert(alignof(UInstancedPlacemenClientSettings) == 0x000008, "Wrong alignment on UInstancedPlacemenClientSettings");
static_assert(sizeof(UInstancedPlacemenClientSettings) == 0x000028, "Wrong size on UInstancedPlacemenClientSettings");

// Class Engine.ParticleModuleEventReceiverSpawn
// 0x00B0 (0x00F0 - 0x0040)
class UParticleModuleEventReceiverSpawn final : public UParticleModuleEventReceiverBase
{
public:
	struct FRawDistributionFloat                  SpawnCount;                                        // 0x0040(0x0030)(Edit, ContainsInstancedReference, NativeAccessSpecifierPublic)
	uint8                                         bUseParticleTime : 1;                              // 0x0070(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bUsePSysLocation : 1;                              // 0x0070(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bInheritVelocity : 1;                              // 0x0070(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_71[0x7];                                       // 0x0071(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	struct FRawDistributionVector                 InheritVelocityScale;                              // 0x0078(0x0060)(Edit, ContainsInstancedReference, NativeAccessSpecifierPublic)
	TArray<class UPhysicalMaterial*>              PhysicalMaterials;                                 // 0x00D8(0x0010)(Edit, ZeroConstructor, UObjectWrapper, NativeAccessSpecifierPublic)
	uint8                                         bBanPhysicalMaterials : 1;                         // 0x00E8(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_E9[0x7];                                       // 0x00E9(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ParticleModuleEventReceiverSpawn">();
	}
	static class UParticleModuleEventReceiverSpawn* GetDefaultObj()
	{
		return GetDefaultObjImpl<UParticleModuleEventReceiverSpawn>();
	}
};
static_assert(alignof(UParticleModuleEventReceiverSpawn) == 0x000008, "Wrong alignment on UParticleModuleEventReceiverSpawn");
static_assert(sizeof(UParticleModuleEventReceiverSpawn) == 0x0000F0, "Wrong size on UParticleModuleEventReceiverSpawn");
static_assert(offsetof(UParticleModuleEventReceiverSpawn, SpawnCount) == 0x000040, "Member 'UParticleModuleEventReceiverSpawn::SpawnCount' has a wrong offset!");
static_assert(offsetof(UParticleModuleEventReceiverSpawn, InheritVelocityScale) == 0x000078, "Member 'UParticleModuleEventReceiverSpawn::InheritVelocityScale' has a wrong offset!");
static_assert(offsetof(UParticleModuleEventReceiverSpawn, PhysicalMaterials) == 0x0000D8, "Member 'UParticleModuleEventReceiverSpawn::PhysicalMaterials' has a wrong offset!");

// Class Engine.MaterialExpressionPerInstanceFadeAmount
// 0x0000 (0x00B0 - 0x00B0)
class UMaterialExpressionPerInstanceFadeAmount final : public UMaterialExpression
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionPerInstanceFadeAmount">();
	}
	static class UMaterialExpressionPerInstanceFadeAmount* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionPerInstanceFadeAmount>();
	}
};
static_assert(alignof(UMaterialExpressionPerInstanceFadeAmount) == 0x000008, "Wrong alignment on UMaterialExpressionPerInstanceFadeAmount");
static_assert(sizeof(UMaterialExpressionPerInstanceFadeAmount) == 0x0000B0, "Wrong size on UMaterialExpressionPerInstanceFadeAmount");

// Class Engine.MaterialExpressionPerInstanceRandom
// 0x0000 (0x00B0 - 0x00B0)
class UMaterialExpressionPerInstanceRandom final : public UMaterialExpression
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionPerInstanceRandom">();
	}
	static class UMaterialExpressionPerInstanceRandom* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionPerInstanceRandom>();
	}
};
static_assert(alignof(UMaterialExpressionPerInstanceRandom) == 0x000008, "Wrong alignment on UMaterialExpressionPerInstanceRandom");
static_assert(sizeof(UMaterialExpressionPerInstanceRandom) == 0x0000B0, "Wrong size on UMaterialExpressionPerInstanceRandom");

// Class Engine.MaterialFunctionMaterialLayerInstance
// 0x0000 (0x00E0 - 0x00E0)
class UMaterialFunctionMaterialLayerInstance final : public UMaterialFunctionInstance
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialFunctionMaterialLayerInstance">();
	}
	static class UMaterialFunctionMaterialLayerInstance* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialFunctionMaterialLayerInstance>();
	}
};
static_assert(alignof(UMaterialFunctionMaterialLayerInstance) == 0x000008, "Wrong alignment on UMaterialFunctionMaterialLayerInstance");
static_assert(sizeof(UMaterialFunctionMaterialLayerInstance) == 0x0000E0, "Wrong size on UMaterialFunctionMaterialLayerInstance");

// Class Engine.MaterialExpressionPinBase
// 0x0018 (0x00C8 - 0x00B0)
class UMaterialExpressionPinBase final : public UMaterialExpression
{
public:
	TArray<struct FCompositeReroute>              ReroutePins;                                       // 0x00B0(0x0010)(Edit, ZeroConstructor, NativeAccessSpecifierPublic)
	EEdGraphPinDirection                          PinDirection;                                      // 0x00C0(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_C1[0x7];                                       // 0x00C1(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionPinBase">();
	}
	static class UMaterialExpressionPinBase* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionPinBase>();
	}
};
static_assert(alignof(UMaterialExpressionPinBase) == 0x000008, "Wrong alignment on UMaterialExpressionPinBase");
static_assert(sizeof(UMaterialExpressionPinBase) == 0x0000C8, "Wrong size on UMaterialExpressionPinBase");
static_assert(offsetof(UMaterialExpressionPinBase, ReroutePins) == 0x0000B0, "Member 'UMaterialExpressionPinBase::ReroutePins' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionPinBase, PinDirection) == 0x0000C0, "Member 'UMaterialExpressionPinBase::PinDirection' has a wrong offset!");

// Class Engine.MaterialExpressionPixelDepth
// 0x0000 (0x00B0 - 0x00B0)
class UMaterialExpressionPixelDepth final : public UMaterialExpression
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionPixelDepth">();
	}
	static class UMaterialExpressionPixelDepth* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionPixelDepth>();
	}
};
static_assert(alignof(UMaterialExpressionPixelDepth) == 0x000008, "Wrong alignment on UMaterialExpressionPixelDepth");
static_assert(sizeof(UMaterialExpressionPixelDepth) == 0x0000B0, "Wrong size on UMaterialExpressionPixelDepth");

// Class Engine.IntSerialization
// 0x0028 (0x0050 - 0x0028)
class UIntSerialization final : public UObject
{
public:
	uint16                                        UnsignedInt16Variable;                             // 0x0028(0x0002)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_2A[0x2];                                       // 0x002A(0x0002)(Fixing Size After Last Property [ Dumper-7 ])
	uint32                                        UnsignedInt32Variable;                             // 0x002C(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint64                                        UnsignedInt64Variable;                             // 0x0030(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int8                                          SignedInt8Variable;                                // 0x0038(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_39[0x1];                                       // 0x0039(0x0001)(Fixing Size After Last Property [ Dumper-7 ])
	int16                                         SignedInt16Variable;                               // 0x003A(0x0002)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_3C[0x4];                                       // 0x003C(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	int64                                         SignedInt64Variable;                               // 0x0040(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         UnsignedInt8Variable;                              // 0x0048(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_49[0x3];                                       // 0x0049(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	int32                                         SignedInt32Variable;                               // 0x004C(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"IntSerialization">();
	}
	static class UIntSerialization* GetDefaultObj()
	{
		return GetDefaultObjImpl<UIntSerialization>();
	}
};
static_assert(alignof(UIntSerialization) == 0x000008, "Wrong alignment on UIntSerialization");
static_assert(sizeof(UIntSerialization) == 0x000050, "Wrong size on UIntSerialization");
static_assert(offsetof(UIntSerialization, UnsignedInt16Variable) == 0x000028, "Member 'UIntSerialization::UnsignedInt16Variable' has a wrong offset!");
static_assert(offsetof(UIntSerialization, UnsignedInt32Variable) == 0x00002C, "Member 'UIntSerialization::UnsignedInt32Variable' has a wrong offset!");
static_assert(offsetof(UIntSerialization, UnsignedInt64Variable) == 0x000030, "Member 'UIntSerialization::UnsignedInt64Variable' has a wrong offset!");
static_assert(offsetof(UIntSerialization, SignedInt8Variable) == 0x000038, "Member 'UIntSerialization::SignedInt8Variable' has a wrong offset!");
static_assert(offsetof(UIntSerialization, SignedInt16Variable) == 0x00003A, "Member 'UIntSerialization::SignedInt16Variable' has a wrong offset!");
static_assert(offsetof(UIntSerialization, SignedInt64Variable) == 0x000040, "Member 'UIntSerialization::SignedInt64Variable' has a wrong offset!");
static_assert(offsetof(UIntSerialization, UnsignedInt8Variable) == 0x000048, "Member 'UIntSerialization::UnsignedInt8Variable' has a wrong offset!");
static_assert(offsetof(UIntSerialization, SignedInt32Variable) == 0x00004C, "Member 'UIntSerialization::SignedInt32Variable' has a wrong offset!");

// Class Engine.MaterialExpressionPower
// 0x0058 (0x0108 - 0x00B0)
class UMaterialExpressionPower final : public UMaterialExpression
{
public:
	struct FExpressionInput                       base;                                              // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       Exponent;                                          // 0x00D8(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	float                                         ConstExponent;                                     // 0x0100(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_104[0x4];                                      // 0x0104(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionPower">();
	}
	static class UMaterialExpressionPower* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionPower>();
	}
};
static_assert(alignof(UMaterialExpressionPower) == 0x000008, "Wrong alignment on UMaterialExpressionPower");
static_assert(sizeof(UMaterialExpressionPower) == 0x000108, "Wrong size on UMaterialExpressionPower");
static_assert(offsetof(UMaterialExpressionPower, base) == 0x0000B0, "Member 'UMaterialExpressionPower::base' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionPower, Exponent) == 0x0000D8, "Member 'UMaterialExpressionPower::Exponent' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionPower, ConstExponent) == 0x000100, "Member 'UMaterialExpressionPower::ConstExponent' has a wrong offset!");

// Class Engine.MaterialExpressionPreSkinnedPosition
// 0x0000 (0x00B0 - 0x00B0)
class UMaterialExpressionPreSkinnedPosition final : public UMaterialExpression
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionPreSkinnedPosition">();
	}
	static class UMaterialExpressionPreSkinnedPosition* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionPreSkinnedPosition>();
	}
};
static_assert(alignof(UMaterialExpressionPreSkinnedPosition) == 0x000008, "Wrong alignment on UMaterialExpressionPreSkinnedPosition");
static_assert(sizeof(UMaterialExpressionPreSkinnedPosition) == 0x0000B0, "Wrong size on UMaterialExpressionPreSkinnedPosition");

// Class Engine.MeshDeformerInstance
// 0x0000 (0x0028 - 0x0028)
class UMeshDeformerInstance : public UObject
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MeshDeformerInstance">();
	}
	static class UMeshDeformerInstance* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMeshDeformerInstance>();
	}
};
static_assert(alignof(UMeshDeformerInstance) == 0x000008, "Wrong alignment on UMeshDeformerInstance");
static_assert(sizeof(UMeshDeformerInstance) == 0x000028, "Wrong size on UMeshDeformerInstance");

// Class Engine.MaterialExpressionPreviousFrameSwitch
// 0x0050 (0x0100 - 0x00B0)
class UMaterialExpressionPreviousFrameSwitch final : public UMaterialExpression
{
public:
	struct FExpressionInput                       CurrentFrame;                                      // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       PreviousFrame;                                     // 0x00D8(0x0028)(NoDestructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionPreviousFrameSwitch">();
	}
	static class UMaterialExpressionPreviousFrameSwitch* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionPreviousFrameSwitch>();
	}
};
static_assert(alignof(UMaterialExpressionPreviousFrameSwitch) == 0x000008, "Wrong alignment on UMaterialExpressionPreviousFrameSwitch");
static_assert(sizeof(UMaterialExpressionPreviousFrameSwitch) == 0x000100, "Wrong size on UMaterialExpressionPreviousFrameSwitch");
static_assert(offsetof(UMaterialExpressionPreviousFrameSwitch, CurrentFrame) == 0x0000B0, "Member 'UMaterialExpressionPreviousFrameSwitch::CurrentFrame' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionPreviousFrameSwitch, PreviousFrame) == 0x0000D8, "Member 'UMaterialExpressionPreviousFrameSwitch::PreviousFrame' has a wrong offset!");

// Class Engine.MaterialExpressionQualitySwitch
// 0x00C8 (0x0178 - 0x00B0)
class UMaterialExpressionQualitySwitch final : public UMaterialExpression
{
public:
	struct FExpressionInput                       Default;                                           // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       Inputs[0x4];                                       // 0x00D8(0x0028)(NoDestructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionQualitySwitch">();
	}
	static class UMaterialExpressionQualitySwitch* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionQualitySwitch>();
	}
};
static_assert(alignof(UMaterialExpressionQualitySwitch) == 0x000008, "Wrong alignment on UMaterialExpressionQualitySwitch");
static_assert(sizeof(UMaterialExpressionQualitySwitch) == 0x000178, "Wrong size on UMaterialExpressionQualitySwitch");
static_assert(offsetof(UMaterialExpressionQualitySwitch, Default) == 0x0000B0, "Member 'UMaterialExpressionQualitySwitch::Default' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionQualitySwitch, Inputs) == 0x0000D8, "Member 'UMaterialExpressionQualitySwitch::Inputs' has a wrong offset!");

// Class Engine.KismetNodeHelperLibrary
// 0x0000 (0x0028 - 0x0028)
class UKismetNodeHelperLibrary final : public UBlueprintFunctionLibrary
{
public:
	static bool BitIsMarked(int32 Data, int32 Index_0);
	static void ClearAllBits(int32* Data);
	static void ClearBit(int32* Data, int32 Index_0);
	static class FName GetEnumeratorName(const class UEnum* Enum, uint8 EnumeratorValue);
	static class FString GetEnumeratorUserFriendlyName(const class UEnum* Enum, uint8 EnumeratorValue);
	static uint8 GetEnumeratorValueFromIndex(const class UEnum* Enum, uint8 EnumeratorIndex);
	static int32 GetFirstUnmarkedBit(int32 Data, int32 StartIdx, int32 NumBits);
	static int32 GetRandomUnmarkedBit(int32 Data, int32 StartIdx, int32 NumBits);
	static int32 GetUnmarkedBit(int32 Data, int32 StartIdx, int32 NumBits, bool bRandom);
	static uint8 GetValidValue(const class UEnum* Enum, uint8 EnumeratorValue);
	static bool HasMarkedBit(int32 Data, int32 NumBits);
	static bool HasUnmarkedBit(int32 Data, int32 NumBits);
	static void MarkBit(int32* Data, int32 Index_0);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"KismetNodeHelperLibrary">();
	}
	static class UKismetNodeHelperLibrary* GetDefaultObj()
	{
		return GetDefaultObjImpl<UKismetNodeHelperLibrary>();
	}
};
static_assert(alignof(UKismetNodeHelperLibrary) == 0x000008, "Wrong alignment on UKismetNodeHelperLibrary");
static_assert(sizeof(UKismetNodeHelperLibrary) == 0x000028, "Wrong size on UKismetNodeHelperLibrary");

// Class Engine.MaterialExpressionReflectionCapturePassSwitch
// 0x0050 (0x0100 - 0x00B0)
class UMaterialExpressionReflectionCapturePassSwitch final : public UMaterialExpression
{
public:
	struct FExpressionInput                       Default;                                           // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       Reflection;                                        // 0x00D8(0x0028)(NoDestructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionReflectionCapturePassSwitch">();
	}
	static class UMaterialExpressionReflectionCapturePassSwitch* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionReflectionCapturePassSwitch>();
	}
};
static_assert(alignof(UMaterialExpressionReflectionCapturePassSwitch) == 0x000008, "Wrong alignment on UMaterialExpressionReflectionCapturePassSwitch");
static_assert(sizeof(UMaterialExpressionReflectionCapturePassSwitch) == 0x000100, "Wrong size on UMaterialExpressionReflectionCapturePassSwitch");
static_assert(offsetof(UMaterialExpressionReflectionCapturePassSwitch, Default) == 0x0000B0, "Member 'UMaterialExpressionReflectionCapturePassSwitch::Default' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionReflectionCapturePassSwitch, Reflection) == 0x0000D8, "Member 'UMaterialExpressionReflectionCapturePassSwitch::Reflection' has a wrong offset!");

// Class Engine.MaterialExpressionReflectionVectorWS
// 0x0030 (0x00E0 - 0x00B0)
class UMaterialExpressionReflectionVectorWS final : public UMaterialExpression
{
public:
	struct FExpressionInput                       CustomWorldNormal;                                 // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	uint8                                         bNormalizeCustomWorldNormal : 1;                   // 0x00D8(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_D9[0x7];                                       // 0x00D9(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionReflectionVectorWS">();
	}
	static class UMaterialExpressionReflectionVectorWS* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionReflectionVectorWS>();
	}
};
static_assert(alignof(UMaterialExpressionReflectionVectorWS) == 0x000008, "Wrong alignment on UMaterialExpressionReflectionVectorWS");
static_assert(sizeof(UMaterialExpressionReflectionVectorWS) == 0x0000E0, "Wrong size on UMaterialExpressionReflectionVectorWS");
static_assert(offsetof(UMaterialExpressionReflectionVectorWS, CustomWorldNormal) == 0x0000B0, "Member 'UMaterialExpressionReflectionVectorWS::CustomWorldNormal' has a wrong offset!");

// Class Engine.ClusterUnionReplicatedProxyComponent
// 0x0058 (0x0100 - 0x00A8)
class UClusterUnionReplicatedProxyComponent final : public UActorComponent
{
public:
	TWeakObjectPtr<class UClusterUnionComponent>  ParentClusterUnion;                                // 0x00A8(0x0008)(ExportObject, Net, ZeroConstructor, InstancedReference, IsPlainOldData, RepNotify, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	bool                                          bNetUpdateParentClusterUnion;                      // 0x00B0(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_B1[0x3];                                       // 0x00B1(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	TWeakObjectPtr<class UPrimitiveComponent>     ChildClusteredComponent;                           // 0x00B4(0x0008)(ExportObject, Net, ZeroConstructor, InstancedReference, IsPlainOldData, RepNotify, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	bool                                          bNetUpdateChildClusteredComponent;                 // 0x00BC(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_BD[0x3];                                       // 0x00BD(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<int32>                                 ParticleBoneIds;                                   // 0x00C0(0x0010)(Net, ZeroConstructor, RepNotify, NativeAccessSpecifierPrivate)
	bool                                          bNetUpdateParticleBoneIds;                         // 0x00D0(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_D1[0x7];                                       // 0x00D1(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<struct FTransform>                     ParticleChildToParents;                            // 0x00D8(0x0010)(Net, ZeroConstructor, RepNotify, NativeAccessSpecifierPrivate)
	bool                                          bNetUpdateParticleChildToParents;                  // 0x00E8(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	bool                                          bIsPendingDeletion;                                // 0x00E9(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_EA[0x16];                                      // 0x00EA(0x0016)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	bool IsPendingDeletion();
	void MarkPendingDeletion();
	void OnRep_ChildClusteredComponent();
	void OnRep_ParentClusterUnion();
	void OnRep_ParticleBoneIds();
	void OnRep_ParticleChildToParents();
	void SetChildClusteredComponent(class UPrimitiveComponent* InComponent);
	void SetParentClusterUnion(class UClusterUnionComponent* InComponent);
	void SetParticleBoneIds(const TArray<int32>& InIds);
	void SetParticleChildToParent(int32 BoneID, const struct FTransform& ChildToParent);

	class UClusterUnionComponent* GetParentClusterUnionComponent() const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ClusterUnionReplicatedProxyComponent">();
	}
	static class UClusterUnionReplicatedProxyComponent* GetDefaultObj()
	{
		return GetDefaultObjImpl<UClusterUnionReplicatedProxyComponent>();
	}
};
static_assert(alignof(UClusterUnionReplicatedProxyComponent) == 0x000008, "Wrong alignment on UClusterUnionReplicatedProxyComponent");
static_assert(sizeof(UClusterUnionReplicatedProxyComponent) == 0x000100, "Wrong size on UClusterUnionReplicatedProxyComponent");
static_assert(offsetof(UClusterUnionReplicatedProxyComponent, ParentClusterUnion) == 0x0000A8, "Member 'UClusterUnionReplicatedProxyComponent::ParentClusterUnion' has a wrong offset!");
static_assert(offsetof(UClusterUnionReplicatedProxyComponent, bNetUpdateParentClusterUnion) == 0x0000B0, "Member 'UClusterUnionReplicatedProxyComponent::bNetUpdateParentClusterUnion' has a wrong offset!");
static_assert(offsetof(UClusterUnionReplicatedProxyComponent, ChildClusteredComponent) == 0x0000B4, "Member 'UClusterUnionReplicatedProxyComponent::ChildClusteredComponent' has a wrong offset!");
static_assert(offsetof(UClusterUnionReplicatedProxyComponent, bNetUpdateChildClusteredComponent) == 0x0000BC, "Member 'UClusterUnionReplicatedProxyComponent::bNetUpdateChildClusteredComponent' has a wrong offset!");
static_assert(offsetof(UClusterUnionReplicatedProxyComponent, ParticleBoneIds) == 0x0000C0, "Member 'UClusterUnionReplicatedProxyComponent::ParticleBoneIds' has a wrong offset!");
static_assert(offsetof(UClusterUnionReplicatedProxyComponent, bNetUpdateParticleBoneIds) == 0x0000D0, "Member 'UClusterUnionReplicatedProxyComponent::bNetUpdateParticleBoneIds' has a wrong offset!");
static_assert(offsetof(UClusterUnionReplicatedProxyComponent, ParticleChildToParents) == 0x0000D8, "Member 'UClusterUnionReplicatedProxyComponent::ParticleChildToParents' has a wrong offset!");
static_assert(offsetof(UClusterUnionReplicatedProxyComponent, bNetUpdateParticleChildToParents) == 0x0000E8, "Member 'UClusterUnionReplicatedProxyComponent::bNetUpdateParticleChildToParents' has a wrong offset!");
static_assert(offsetof(UClusterUnionReplicatedProxyComponent, bIsPendingDeletion) == 0x0000E9, "Member 'UClusterUnionReplicatedProxyComponent::bIsPendingDeletion' has a wrong offset!");

// Class Engine.MaterialExpressionRound
// 0x0028 (0x00D8 - 0x00B0)
class UMaterialExpressionRound final : public UMaterialExpression
{
public:
	struct FExpressionInput                       Input;                                             // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionRound">();
	}
	static class UMaterialExpressionRound* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionRound>();
	}
};
static_assert(alignof(UMaterialExpressionRound) == 0x000008, "Wrong alignment on UMaterialExpressionRound");
static_assert(sizeof(UMaterialExpressionRound) == 0x0000D8, "Wrong size on UMaterialExpressionRound");
static_assert(offsetof(UMaterialExpressionRound, Input) == 0x0000B0, "Member 'UMaterialExpressionRound::Input' has a wrong offset!");

// Class Engine.MorphTarget
// 0x0018 (0x0040 - 0x0028)
class UMorphTarget final : public UObject
{
public:
	class USkeletalMesh*                          BaseSkelMesh;                                      // 0x0028(0x0008)(ZeroConstructor, NoDestructor, AssetRegistrySearchable, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_30[0x10];                                      // 0x0030(0x0010)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MorphTarget">();
	}
	static class UMorphTarget* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMorphTarget>();
	}
};
static_assert(alignof(UMorphTarget) == 0x000008, "Wrong alignment on UMorphTarget");
static_assert(sizeof(UMorphTarget) == 0x000040, "Wrong size on UMorphTarget");
static_assert(offsetof(UMorphTarget, BaseSkelMesh) == 0x000028, "Member 'UMorphTarget::BaseSkelMesh' has a wrong offset!");

// Class Engine.MaterialExpressionRuntimeVirtualTextureOutput
// 0x0118 (0x01C8 - 0x00B0)
class UMaterialExpressionRuntimeVirtualTextureOutput final : public UMaterialExpressionCustomOutput
{
public:
	struct FExpressionInput                       BaseColor;                                         // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       Specular;                                          // 0x00D8(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       Roughness;                                         // 0x0100(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       Normal;                                            // 0x0128(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       WorldHeight;                                       // 0x0150(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       Opacity;                                           // 0x0178(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       Mask;                                              // 0x01A0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionRuntimeVirtualTextureOutput">();
	}
	static class UMaterialExpressionRuntimeVirtualTextureOutput* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionRuntimeVirtualTextureOutput>();
	}
};
static_assert(alignof(UMaterialExpressionRuntimeVirtualTextureOutput) == 0x000008, "Wrong alignment on UMaterialExpressionRuntimeVirtualTextureOutput");
static_assert(sizeof(UMaterialExpressionRuntimeVirtualTextureOutput) == 0x0001C8, "Wrong size on UMaterialExpressionRuntimeVirtualTextureOutput");
static_assert(offsetof(UMaterialExpressionRuntimeVirtualTextureOutput, BaseColor) == 0x0000B0, "Member 'UMaterialExpressionRuntimeVirtualTextureOutput::BaseColor' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionRuntimeVirtualTextureOutput, Specular) == 0x0000D8, "Member 'UMaterialExpressionRuntimeVirtualTextureOutput::Specular' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionRuntimeVirtualTextureOutput, Roughness) == 0x000100, "Member 'UMaterialExpressionRuntimeVirtualTextureOutput::Roughness' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionRuntimeVirtualTextureOutput, Normal) == 0x000128, "Member 'UMaterialExpressionRuntimeVirtualTextureOutput::Normal' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionRuntimeVirtualTextureOutput, WorldHeight) == 0x000150, "Member 'UMaterialExpressionRuntimeVirtualTextureOutput::WorldHeight' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionRuntimeVirtualTextureOutput, Opacity) == 0x000178, "Member 'UMaterialExpressionRuntimeVirtualTextureOutput::Opacity' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionRuntimeVirtualTextureOutput, Mask) == 0x0001A0, "Member 'UMaterialExpressionRuntimeVirtualTextureOutput::Mask' has a wrong offset!");

// Class Engine.MaterialExpressionRuntimeVirtualTextureReplace
// 0x0050 (0x0100 - 0x00B0)
class UMaterialExpressionRuntimeVirtualTextureReplace final : public UMaterialExpression
{
public:
	struct FExpressionInput                       Default;                                           // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       VirtualTextureOutput;                              // 0x00D8(0x0028)(NoDestructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionRuntimeVirtualTextureReplace">();
	}
	static class UMaterialExpressionRuntimeVirtualTextureReplace* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionRuntimeVirtualTextureReplace>();
	}
};
static_assert(alignof(UMaterialExpressionRuntimeVirtualTextureReplace) == 0x000008, "Wrong alignment on UMaterialExpressionRuntimeVirtualTextureReplace");
static_assert(sizeof(UMaterialExpressionRuntimeVirtualTextureReplace) == 0x000100, "Wrong size on UMaterialExpressionRuntimeVirtualTextureReplace");
static_assert(offsetof(UMaterialExpressionRuntimeVirtualTextureReplace, Default) == 0x0000B0, "Member 'UMaterialExpressionRuntimeVirtualTextureReplace::Default' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionRuntimeVirtualTextureReplace, VirtualTextureOutput) == 0x0000D8, "Member 'UMaterialExpressionRuntimeVirtualTextureReplace::VirtualTextureOutput' has a wrong offset!");

// Class Engine.MaterialParameterCollectionInstance
// 0x00F8 (0x0120 - 0x0028)
class UMaterialParameterCollectionInstance final : public UObject
{
public:
	uint8                                         Pad_28[0x4];                                       // 0x0028(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	TWeakObjectPtr<class UMaterialParameterCollection> Collection;                                   // 0x002C(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, Protected, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_34[0xEC];                                      // 0x0034(0x00EC)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialParameterCollectionInstance">();
	}
	static class UMaterialParameterCollectionInstance* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialParameterCollectionInstance>();
	}
};
static_assert(alignof(UMaterialParameterCollectionInstance) == 0x000008, "Wrong alignment on UMaterialParameterCollectionInstance");
static_assert(sizeof(UMaterialParameterCollectionInstance) == 0x000120, "Wrong size on UMaterialParameterCollectionInstance");
static_assert(offsetof(UMaterialParameterCollectionInstance, Collection) == 0x00002C, "Member 'UMaterialParameterCollectionInstance::Collection' has a wrong offset!");

// Class Engine.MaterialExpressionRuntimeVirtualTextureSample
// 0x0088 (0x0138 - 0x00B0)
class UMaterialExpressionRuntimeVirtualTextureSample : public UMaterialExpression
{
public:
	struct FExpressionInput                       Coordinates;                                       // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       WorldPosition;                                     // 0x00D8(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       MipValue;                                          // 0x0100(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	class URuntimeVirtualTexture*                 VirtualTexture;                                    // 0x0128(0x0008)(Edit, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	ERuntimeVirtualTextureMaterialType            MaterialType;                                      // 0x0130(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bSinglePhysicalSpace;                              // 0x0131(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bAdaptive;                                         // 0x0132(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bEnableFeedback;                                   // 0x0133(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	ERuntimeVirtualTextureMipValueMode            MipValueMode;                                      // 0x0134(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	ERuntimeVirtualTextureTextureAddressMode      TextureAddressMode;                                // 0x0135(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_136[0x2];                                      // 0x0136(0x0002)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionRuntimeVirtualTextureSample">();
	}
	static class UMaterialExpressionRuntimeVirtualTextureSample* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionRuntimeVirtualTextureSample>();
	}
};
static_assert(alignof(UMaterialExpressionRuntimeVirtualTextureSample) == 0x000008, "Wrong alignment on UMaterialExpressionRuntimeVirtualTextureSample");
static_assert(sizeof(UMaterialExpressionRuntimeVirtualTextureSample) == 0x000138, "Wrong size on UMaterialExpressionRuntimeVirtualTextureSample");
static_assert(offsetof(UMaterialExpressionRuntimeVirtualTextureSample, Coordinates) == 0x0000B0, "Member 'UMaterialExpressionRuntimeVirtualTextureSample::Coordinates' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionRuntimeVirtualTextureSample, WorldPosition) == 0x0000D8, "Member 'UMaterialExpressionRuntimeVirtualTextureSample::WorldPosition' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionRuntimeVirtualTextureSample, MipValue) == 0x000100, "Member 'UMaterialExpressionRuntimeVirtualTextureSample::MipValue' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionRuntimeVirtualTextureSample, VirtualTexture) == 0x000128, "Member 'UMaterialExpressionRuntimeVirtualTextureSample::VirtualTexture' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionRuntimeVirtualTextureSample, MaterialType) == 0x000130, "Member 'UMaterialExpressionRuntimeVirtualTextureSample::MaterialType' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionRuntimeVirtualTextureSample, bSinglePhysicalSpace) == 0x000131, "Member 'UMaterialExpressionRuntimeVirtualTextureSample::bSinglePhysicalSpace' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionRuntimeVirtualTextureSample, bAdaptive) == 0x000132, "Member 'UMaterialExpressionRuntimeVirtualTextureSample::bAdaptive' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionRuntimeVirtualTextureSample, bEnableFeedback) == 0x000133, "Member 'UMaterialExpressionRuntimeVirtualTextureSample::bEnableFeedback' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionRuntimeVirtualTextureSample, MipValueMode) == 0x000134, "Member 'UMaterialExpressionRuntimeVirtualTextureSample::MipValueMode' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionRuntimeVirtualTextureSample, TextureAddressMode) == 0x000135, "Member 'UMaterialExpressionRuntimeVirtualTextureSample::TextureAddressMode' has a wrong offset!");

// Class Engine.PhysicalAnimationComponent
// 0x0040 (0x00E8 - 0x00A8)
class UPhysicalAnimationComponent final : public UActorComponent
{
public:
	float                                         StrengthMultiplyer;                                // 0x00A8(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_AC[0x4];                                       // 0x00AC(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	class USkeletalMeshComponent*                 SkeletalMeshComponent;                             // 0x00B0(0x0008)(ExportObject, ZeroConstructor, InstancedReference, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_B8[0x30];                                      // 0x00B8(0x0030)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void ApplyPhysicalAnimationProfileBelow(class FName BodyName, class FName ProfileName, bool bIncludeSelf, bool bClearNotFound);
	void ApplyPhysicalAnimationSettings(class FName BodyName, const struct FPhysicalAnimationData& PhysicalAnimationData);
	void ApplyPhysicalAnimationSettingsBelow(class FName BodyName, const struct FPhysicalAnimationData& PhysicalAnimationData, bool bIncludeSelf);
	void SetSkeletalMeshComponent(class USkeletalMeshComponent* InSkeletalMeshComponent);
	void SetStrengthMultiplyer(float InStrengthMultiplyer);

	struct FTransform GetBodyTargetTransform(class FName BodyName) const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"PhysicalAnimationComponent">();
	}
	static class UPhysicalAnimationComponent* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPhysicalAnimationComponent>();
	}
};
static_assert(alignof(UPhysicalAnimationComponent) == 0x000008, "Wrong alignment on UPhysicalAnimationComponent");
static_assert(sizeof(UPhysicalAnimationComponent) == 0x0000E8, "Wrong size on UPhysicalAnimationComponent");
static_assert(offsetof(UPhysicalAnimationComponent, StrengthMultiplyer) == 0x0000A8, "Member 'UPhysicalAnimationComponent::StrengthMultiplyer' has a wrong offset!");
static_assert(offsetof(UPhysicalAnimationComponent, SkeletalMeshComponent) == 0x0000B0, "Member 'UPhysicalAnimationComponent::SkeletalMeshComponent' has a wrong offset!");

// Class Engine.MaterialExpressionRuntimeVirtualTextureSampleParameter
// 0x0028 (0x0160 - 0x0138)
class UMaterialExpressionRuntimeVirtualTextureSampleParameter final : public UMaterialExpressionRuntimeVirtualTextureSample
{
public:
	class FName                                   ParameterName;                                     // 0x0138(0x0008)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FGuid                                  ExpressionGUID;                                    // 0x0140(0x0010)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FName                                   Group;                                             // 0x0150(0x0008)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         SortPriority;                                      // 0x0158(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_15C[0x4];                                      // 0x015C(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionRuntimeVirtualTextureSampleParameter">();
	}
	static class UMaterialExpressionRuntimeVirtualTextureSampleParameter* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionRuntimeVirtualTextureSampleParameter>();
	}
};
static_assert(alignof(UMaterialExpressionRuntimeVirtualTextureSampleParameter) == 0x000008, "Wrong alignment on UMaterialExpressionRuntimeVirtualTextureSampleParameter");
static_assert(sizeof(UMaterialExpressionRuntimeVirtualTextureSampleParameter) == 0x000160, "Wrong size on UMaterialExpressionRuntimeVirtualTextureSampleParameter");
static_assert(offsetof(UMaterialExpressionRuntimeVirtualTextureSampleParameter, ParameterName) == 0x000138, "Member 'UMaterialExpressionRuntimeVirtualTextureSampleParameter::ParameterName' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionRuntimeVirtualTextureSampleParameter, ExpressionGUID) == 0x000140, "Member 'UMaterialExpressionRuntimeVirtualTextureSampleParameter::ExpressionGUID' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionRuntimeVirtualTextureSampleParameter, Group) == 0x000150, "Member 'UMaterialExpressionRuntimeVirtualTextureSampleParameter::Group' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionRuntimeVirtualTextureSampleParameter, SortPriority) == 0x000158, "Member 'UMaterialExpressionRuntimeVirtualTextureSampleParameter::SortPriority' has a wrong offset!");

// Class Engine.NavigationDataInterface
// 0x0000 (0x0000 - 0x0000)
class INavigationDataInterface final
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"NavigationDataInterface">();
	}
	static class INavigationDataInterface* GetDefaultObj()
	{
		return GetDefaultObjImpl<INavigationDataInterface>();
	}

	class UObject* AsUObject()
	{
		return reinterpret_cast<UObject*>(this);
	}
	const class UObject* AsUObject() const
	{
		return reinterpret_cast<const UObject*>(this);
	}
};
static_assert(alignof(INavigationDataInterface) == 0x000001, "Wrong alignment on INavigationDataInterface");
static_assert(sizeof(INavigationDataInterface) == 0x000001, "Wrong size on INavigationDataInterface");

// Class Engine.MaterialExpressionSamplePhysicsVectorField
// 0x0030 (0x00E0 - 0x00B0)
class UMaterialExpressionSamplePhysicsVectorField final : public UMaterialExpression
{
public:
	struct FExpressionInput                       WorldPosition;                                     // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	EFieldVectorType                              FieldTarget;                                       // 0x00D8(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_D9[0x7];                                       // 0x00D9(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionSamplePhysicsVectorField">();
	}
	static class UMaterialExpressionSamplePhysicsVectorField* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionSamplePhysicsVectorField>();
	}
};
static_assert(alignof(UMaterialExpressionSamplePhysicsVectorField) == 0x000008, "Wrong alignment on UMaterialExpressionSamplePhysicsVectorField");
static_assert(sizeof(UMaterialExpressionSamplePhysicsVectorField) == 0x0000E0, "Wrong size on UMaterialExpressionSamplePhysicsVectorField");
static_assert(offsetof(UMaterialExpressionSamplePhysicsVectorField, WorldPosition) == 0x0000B0, "Member 'UMaterialExpressionSamplePhysicsVectorField::WorldPosition' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionSamplePhysicsVectorField, FieldTarget) == 0x0000D8, "Member 'UMaterialExpressionSamplePhysicsVectorField::FieldTarget' has a wrong offset!");

// Class Engine.MaterialExpressionSamplePhysicsScalarField
// 0x0030 (0x00E0 - 0x00B0)
class UMaterialExpressionSamplePhysicsScalarField final : public UMaterialExpression
{
public:
	struct FExpressionInput                       WorldPosition;                                     // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	EFieldScalarType                              FieldTarget;                                       // 0x00D8(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_D9[0x7];                                       // 0x00D9(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionSamplePhysicsScalarField">();
	}
	static class UMaterialExpressionSamplePhysicsScalarField* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionSamplePhysicsScalarField>();
	}
};
static_assert(alignof(UMaterialExpressionSamplePhysicsScalarField) == 0x000008, "Wrong alignment on UMaterialExpressionSamplePhysicsScalarField");
static_assert(sizeof(UMaterialExpressionSamplePhysicsScalarField) == 0x0000E0, "Wrong size on UMaterialExpressionSamplePhysicsScalarField");
static_assert(offsetof(UMaterialExpressionSamplePhysicsScalarField, WorldPosition) == 0x0000B0, "Member 'UMaterialExpressionSamplePhysicsScalarField::WorldPosition' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionSamplePhysicsScalarField, FieldTarget) == 0x0000D8, "Member 'UMaterialExpressionSamplePhysicsScalarField::FieldTarget' has a wrong offset!");

// Class Engine.PhysicsCollisionHandler
// 0x0018 (0x0040 - 0x0028)
class UPhysicsCollisionHandler final : public UObject
{
public:
	float                                         ImpactThreshold;                                   // 0x0028(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         ImpactReFireDelay;                                 // 0x002C(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class USoundBase*                             DefaultImpactSound;                                // 0x0030(0x0008)(Edit, BlueprintVisible, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         LastImpactSoundTime;                               // 0x0038(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_3C[0x4];                                       // 0x003C(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"PhysicsCollisionHandler">();
	}
	static class UPhysicsCollisionHandler* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPhysicsCollisionHandler>();
	}
};
static_assert(alignof(UPhysicsCollisionHandler) == 0x000008, "Wrong alignment on UPhysicsCollisionHandler");
static_assert(sizeof(UPhysicsCollisionHandler) == 0x000040, "Wrong size on UPhysicsCollisionHandler");
static_assert(offsetof(UPhysicsCollisionHandler, ImpactThreshold) == 0x000028, "Member 'UPhysicsCollisionHandler::ImpactThreshold' has a wrong offset!");
static_assert(offsetof(UPhysicsCollisionHandler, ImpactReFireDelay) == 0x00002C, "Member 'UPhysicsCollisionHandler::ImpactReFireDelay' has a wrong offset!");
static_assert(offsetof(UPhysicsCollisionHandler, DefaultImpactSound) == 0x000030, "Member 'UPhysicsCollisionHandler::DefaultImpactSound' has a wrong offset!");
static_assert(offsetof(UPhysicsCollisionHandler, LastImpactSoundTime) == 0x000038, "Member 'UPhysicsCollisionHandler::LastImpactSoundTime' has a wrong offset!");

// Class Engine.MaterialExpressionSaturate
// 0x0028 (0x00D8 - 0x00B0)
class UMaterialExpressionSaturate final : public UMaterialExpression
{
public:
	struct FExpressionInput                       Input;                                             // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionSaturate">();
	}
	static class UMaterialExpressionSaturate* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionSaturate>();
	}
};
static_assert(alignof(UMaterialExpressionSaturate) == 0x000008, "Wrong alignment on UMaterialExpressionSaturate");
static_assert(sizeof(UMaterialExpressionSaturate) == 0x0000D8, "Wrong size on UMaterialExpressionSaturate");
static_assert(offsetof(UMaterialExpressionSaturate, Input) == 0x0000B0, "Member 'UMaterialExpressionSaturate::Input' has a wrong offset!");

// Class Engine.MaterialExpressionSceneDepth
// 0x0068 (0x0118 - 0x00B0)
class UMaterialExpressionSceneDepth final : public UMaterialExpression
{
public:
	EMaterialSceneAttributeInputMode              InputMode;                                         // 0x00B0(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_B1[0x7];                                       // 0x00B1(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	struct FExpressionInput                       Input;                                             // 0x00B8(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       Coordinates;                                       // 0x00E0(0x0028)(Deprecated, NoDestructor, NativeAccessSpecifierPublic)
	struct FVector2D                              ConstInput;                                        // 0x0108(0x0010)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionSceneDepth">();
	}
	static class UMaterialExpressionSceneDepth* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionSceneDepth>();
	}
};
static_assert(alignof(UMaterialExpressionSceneDepth) == 0x000008, "Wrong alignment on UMaterialExpressionSceneDepth");
static_assert(sizeof(UMaterialExpressionSceneDepth) == 0x000118, "Wrong size on UMaterialExpressionSceneDepth");
static_assert(offsetof(UMaterialExpressionSceneDepth, InputMode) == 0x0000B0, "Member 'UMaterialExpressionSceneDepth::InputMode' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionSceneDepth, Input) == 0x0000B8, "Member 'UMaterialExpressionSceneDepth::Input' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionSceneDepth, Coordinates) == 0x0000E0, "Member 'UMaterialExpressionSceneDepth::Coordinates' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionSceneDepth, ConstInput) == 0x000108, "Member 'UMaterialExpressionSceneDepth::ConstInput' has a wrong offset!");

// Class Engine.NavAreaBase
// 0x0008 (0x0030 - 0x0028)
class UNavAreaBase : public UObject
{
public:
	uint8                                         Pad_28[0x8];                                       // 0x0028(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"NavAreaBase">();
	}
	static class UNavAreaBase* GetDefaultObj()
	{
		return GetDefaultObjImpl<UNavAreaBase>();
	}
};
static_assert(alignof(UNavAreaBase) == 0x000008, "Wrong alignment on UNavAreaBase");
static_assert(sizeof(UNavAreaBase) == 0x000030, "Wrong size on UNavAreaBase");

// Class Engine.MaterialExpressionSceneDepthWithoutWater
// 0x0048 (0x00F8 - 0x00B0)
class UMaterialExpressionSceneDepthWithoutWater final : public UMaterialExpression
{
public:
	EMaterialSceneAttributeInputMode              InputMode;                                         // 0x00B0(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_B1[0x7];                                       // 0x00B1(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	struct FExpressionInput                       Input;                                             // 0x00B8(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FVector2D                              ConstInput;                                        // 0x00E0(0x0010)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         FallbackDepth;                                     // 0x00F0(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_F4[0x4];                                       // 0x00F4(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionSceneDepthWithoutWater">();
	}
	static class UMaterialExpressionSceneDepthWithoutWater* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionSceneDepthWithoutWater>();
	}
};
static_assert(alignof(UMaterialExpressionSceneDepthWithoutWater) == 0x000008, "Wrong alignment on UMaterialExpressionSceneDepthWithoutWater");
static_assert(sizeof(UMaterialExpressionSceneDepthWithoutWater) == 0x0000F8, "Wrong size on UMaterialExpressionSceneDepthWithoutWater");
static_assert(offsetof(UMaterialExpressionSceneDepthWithoutWater, InputMode) == 0x0000B0, "Member 'UMaterialExpressionSceneDepthWithoutWater::InputMode' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionSceneDepthWithoutWater, Input) == 0x0000B8, "Member 'UMaterialExpressionSceneDepthWithoutWater::Input' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionSceneDepthWithoutWater, ConstInput) == 0x0000E0, "Member 'UMaterialExpressionSceneDepthWithoutWater::ConstInput' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionSceneDepthWithoutWater, FallbackDepth) == 0x0000F0, "Member 'UMaterialExpressionSceneDepthWithoutWater::FallbackDepth' has a wrong offset!");

// Class Engine.MaterialExpressionSceneTexelSize
// 0x0000 (0x00B0 - 0x00B0)
class UMaterialExpressionSceneTexelSize final : public UMaterialExpression
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionSceneTexelSize">();
	}
	static class UMaterialExpressionSceneTexelSize* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionSceneTexelSize>();
	}
};
static_assert(alignof(UMaterialExpressionSceneTexelSize) == 0x000008, "Wrong alignment on UMaterialExpressionSceneTexelSize");
static_assert(sizeof(UMaterialExpressionSceneTexelSize) == 0x0000B0, "Wrong size on UMaterialExpressionSceneTexelSize");

// Class Engine.LevelInstanceInterface
// 0x0000 (0x0000 - 0x0000)
class ILevelInstanceInterface final
{
public:
	void LoadLevelInstance();
	void UnloadLevelInstance();

	const TSoftObjectPtr<class UWorld> GetWorldAsset() const;
	bool IsLoaded() const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"LevelInstanceInterface">();
	}
	static class ILevelInstanceInterface* GetDefaultObj()
	{
		return GetDefaultObjImpl<ILevelInstanceInterface>();
	}

	class UObject* AsUObject()
	{
		return reinterpret_cast<UObject*>(this);
	}
	const class UObject* AsUObject() const
	{
		return reinterpret_cast<const UObject*>(this);
	}
};
static_assert(alignof(ILevelInstanceInterface) == 0x000001, "Wrong alignment on ILevelInstanceInterface");
static_assert(sizeof(ILevelInstanceInterface) == 0x000001, "Wrong size on ILevelInstanceInterface");

// Class Engine.Console
// 0x0108 (0x0130 - 0x0028)
class UConsole final : public UObject
{
public:
	uint8                                         Pad_28[0x10];                                      // 0x0028(0x0010)(Fixing Size After Last Property [ Dumper-7 ])
	class ULocalPlayer*                           ConsoleTargetPlayer;                               // 0x0038(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UTexture2D*                             DefaultTexture_Black;                              // 0x0040(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UTexture2D*                             DefaultTexture_White;                              // 0x0048(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_50[0x18];                                      // 0x0050(0x0018)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<class FString>                         HistoryBuffer;                                     // 0x0068(0x0010)(ZeroConstructor, Config, NativeAccessSpecifierPublic)
	uint8                                         Pad_78[0xB8];                                      // 0x0078(0x00B8)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"Console">();
	}
	static class UConsole* GetDefaultObj()
	{
		return GetDefaultObjImpl<UConsole>();
	}
};
static_assert(alignof(UConsole) == 0x000008, "Wrong alignment on UConsole");
static_assert(sizeof(UConsole) == 0x000130, "Wrong size on UConsole");
static_assert(offsetof(UConsole, ConsoleTargetPlayer) == 0x000038, "Member 'UConsole::ConsoleTargetPlayer' has a wrong offset!");
static_assert(offsetof(UConsole, DefaultTexture_Black) == 0x000040, "Member 'UConsole::DefaultTexture_Black' has a wrong offset!");
static_assert(offsetof(UConsole, DefaultTexture_White) == 0x000048, "Member 'UConsole::DefaultTexture_White' has a wrong offset!");
static_assert(offsetof(UConsole, HistoryBuffer) == 0x000068, "Member 'UConsole::HistoryBuffer' has a wrong offset!");

// Class Engine.MaterialExpressionSceneTexture
// 0x0030 (0x00E0 - 0x00B0)
class UMaterialExpressionSceneTexture final : public UMaterialExpression
{
public:
	struct FExpressionInput                       Coordinates;                                       // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	ESceneTextureId                               SceneTextureId;                                    // 0x00D8(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bFiltered;                                         // 0x00D9(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_DA[0x6];                                       // 0x00DA(0x0006)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionSceneTexture">();
	}
	static class UMaterialExpressionSceneTexture* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionSceneTexture>();
	}
};
static_assert(alignof(UMaterialExpressionSceneTexture) == 0x000008, "Wrong alignment on UMaterialExpressionSceneTexture");
static_assert(sizeof(UMaterialExpressionSceneTexture) == 0x0000E0, "Wrong size on UMaterialExpressionSceneTexture");
static_assert(offsetof(UMaterialExpressionSceneTexture, Coordinates) == 0x0000B0, "Member 'UMaterialExpressionSceneTexture::Coordinates' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionSceneTexture, SceneTextureId) == 0x0000D8, "Member 'UMaterialExpressionSceneTexture::SceneTextureId' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionSceneTexture, bFiltered) == 0x0000D9, "Member 'UMaterialExpressionSceneTexture::bFiltered' has a wrong offset!");

// Class Engine.MaterialExpressionScreenPosition
// 0x0000 (0x00B0 - 0x00B0)
class UMaterialExpressionScreenPosition final : public UMaterialExpression
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionScreenPosition">();
	}
	static class UMaterialExpressionScreenPosition* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionScreenPosition>();
	}
};
static_assert(alignof(UMaterialExpressionScreenPosition) == 0x000008, "Wrong alignment on UMaterialExpressionScreenPosition");
static_assert(sizeof(UMaterialExpressionScreenPosition) == 0x0000B0, "Wrong size on UMaterialExpressionScreenPosition");

// Class Engine.MaterialExpressionShadingPathSwitch
// 0x00A0 (0x0150 - 0x00B0)
class UMaterialExpressionShadingPathSwitch final : public UMaterialExpression
{
public:
	struct FExpressionInput                       Default;                                           // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       Inputs[0x3];                                       // 0x00D8(0x0028)(NoDestructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionShadingPathSwitch">();
	}
	static class UMaterialExpressionShadingPathSwitch* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionShadingPathSwitch>();
	}
};
static_assert(alignof(UMaterialExpressionShadingPathSwitch) == 0x000008, "Wrong alignment on UMaterialExpressionShadingPathSwitch");
static_assert(sizeof(UMaterialExpressionShadingPathSwitch) == 0x000150, "Wrong size on UMaterialExpressionShadingPathSwitch");
static_assert(offsetof(UMaterialExpressionShadingPathSwitch, Default) == 0x0000B0, "Member 'UMaterialExpressionShadingPathSwitch::Default' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionShadingPathSwitch, Inputs) == 0x0000D8, "Member 'UMaterialExpressionShadingPathSwitch::Inputs' has a wrong offset!");

// Class Engine.MaterialExpressionShadowReplace
// 0x0050 (0x0100 - 0x00B0)
class UMaterialExpressionShadowReplace final : public UMaterialExpression
{
public:
	struct FExpressionInput                       Default;                                           // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       Shadow;                                            // 0x00D8(0x0028)(NoDestructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionShadowReplace">();
	}
	static class UMaterialExpressionShadowReplace* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionShadowReplace>();
	}
};
static_assert(alignof(UMaterialExpressionShadowReplace) == 0x000008, "Wrong alignment on UMaterialExpressionShadowReplace");
static_assert(sizeof(UMaterialExpressionShadowReplace) == 0x000100, "Wrong size on UMaterialExpressionShadowReplace");
static_assert(offsetof(UMaterialExpressionShadowReplace, Default) == 0x0000B0, "Member 'UMaterialExpressionShadowReplace::Default' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionShadowReplace, Shadow) == 0x0000D8, "Member 'UMaterialExpressionShadowReplace::Shadow' has a wrong offset!");

// Class Engine.LightmassPrimitiveSettingsObject
// 0x0018 (0x0040 - 0x0028)
class ULightmassPrimitiveSettingsObject final : public UObject
{
public:
	struct FLightmassPrimitiveSettings            LightmassSettings;                                 // 0x0028(0x0018)(Edit, NoDestructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"LightmassPrimitiveSettingsObject">();
	}
	static class ULightmassPrimitiveSettingsObject* GetDefaultObj()
	{
		return GetDefaultObjImpl<ULightmassPrimitiveSettingsObject>();
	}
};
static_assert(alignof(ULightmassPrimitiveSettingsObject) == 0x000008, "Wrong alignment on ULightmassPrimitiveSettingsObject");
static_assert(sizeof(ULightmassPrimitiveSettingsObject) == 0x000040, "Wrong size on ULightmassPrimitiveSettingsObject");
static_assert(offsetof(ULightmassPrimitiveSettingsObject, LightmassSettings) == 0x000028, "Member 'ULightmassPrimitiveSettingsObject::LightmassSettings' has a wrong offset!");

// Class Engine.MaterialExpressionSine
// 0x0030 (0x00E0 - 0x00B0)
class UMaterialExpressionSine final : public UMaterialExpression
{
public:
	struct FExpressionInput                       Input;                                             // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	float                                         Period;                                            // 0x00D8(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_DC[0x4];                                       // 0x00DC(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionSine">();
	}
	static class UMaterialExpressionSine* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionSine>();
	}
};
static_assert(alignof(UMaterialExpressionSine) == 0x000008, "Wrong alignment on UMaterialExpressionSine");
static_assert(sizeof(UMaterialExpressionSine) == 0x0000E0, "Wrong size on UMaterialExpressionSine");
static_assert(offsetof(UMaterialExpressionSine, Input) == 0x0000B0, "Member 'UMaterialExpressionSine::Input' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionSine, Period) == 0x0000D8, "Member 'UMaterialExpressionSine::Period' has a wrong offset!");

// Class Engine.MaterialExpressionSkyAtmosphereLightDiskLuminance
// 0x0030 (0x00E0 - 0x00B0)
class UMaterialExpressionSkyAtmosphereLightDiskLuminance final : public UMaterialExpression
{
public:
	int32                                         LightIndex;                                        // 0x00B0(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_B4[0x4];                                       // 0x00B4(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	struct FExpressionInput                       DiskAngularDiameterOverride;                       // 0x00B8(0x0028)(NoDestructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionSkyAtmosphereLightDiskLuminance">();
	}
	static class UMaterialExpressionSkyAtmosphereLightDiskLuminance* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionSkyAtmosphereLightDiskLuminance>();
	}
};
static_assert(alignof(UMaterialExpressionSkyAtmosphereLightDiskLuminance) == 0x000008, "Wrong alignment on UMaterialExpressionSkyAtmosphereLightDiskLuminance");
static_assert(sizeof(UMaterialExpressionSkyAtmosphereLightDiskLuminance) == 0x0000E0, "Wrong size on UMaterialExpressionSkyAtmosphereLightDiskLuminance");
static_assert(offsetof(UMaterialExpressionSkyAtmosphereLightDiskLuminance, LightIndex) == 0x0000B0, "Member 'UMaterialExpressionSkyAtmosphereLightDiskLuminance::LightIndex' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionSkyAtmosphereLightDiskLuminance, DiskAngularDiameterOverride) == 0x0000B8, "Member 'UMaterialExpressionSkyAtmosphereLightDiskLuminance::DiskAngularDiameterOverride' has a wrong offset!");

// Class Engine.MaterialExpressionSkyLightEnvMapSample
// 0x0050 (0x0100 - 0x00B0)
class UMaterialExpressionSkyLightEnvMapSample final : public UMaterialExpression
{
public:
	struct FExpressionInput                       Direction;                                         // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       Roughness;                                         // 0x00D8(0x0028)(NoDestructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionSkyLightEnvMapSample">();
	}
	static class UMaterialExpressionSkyLightEnvMapSample* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionSkyLightEnvMapSample>();
	}
};
static_assert(alignof(UMaterialExpressionSkyLightEnvMapSample) == 0x000008, "Wrong alignment on UMaterialExpressionSkyLightEnvMapSample");
static_assert(sizeof(UMaterialExpressionSkyLightEnvMapSample) == 0x000100, "Wrong size on UMaterialExpressionSkyLightEnvMapSample");
static_assert(offsetof(UMaterialExpressionSkyLightEnvMapSample, Direction) == 0x0000B0, "Member 'UMaterialExpressionSkyLightEnvMapSample::Direction' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionSkyLightEnvMapSample, Roughness) == 0x0000D8, "Member 'UMaterialExpressionSkyLightEnvMapSample::Roughness' has a wrong offset!");

// Class Engine.ParticleModuleColorScaleOverLife
// 0x0098 (0x00C8 - 0x0030)
class UParticleModuleColorScaleOverLife final : public UParticleModuleColorBase
{
public:
	struct FRawDistributionVector                 ColorScaleOverLife;                                // 0x0030(0x0060)(Edit, ContainsInstancedReference, NativeAccessSpecifierPublic)
	struct FRawDistributionFloat                  AlphaScaleOverLife;                                // 0x0090(0x0030)(Edit, ContainsInstancedReference, NativeAccessSpecifierPublic)
	uint8                                         bEmitterTime : 1;                                  // 0x00C0(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_C1[0x7];                                       // 0x00C1(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ParticleModuleColorScaleOverLife">();
	}
	static class UParticleModuleColorScaleOverLife* GetDefaultObj()
	{
		return GetDefaultObjImpl<UParticleModuleColorScaleOverLife>();
	}
};
static_assert(alignof(UParticleModuleColorScaleOverLife) == 0x000008, "Wrong alignment on UParticleModuleColorScaleOverLife");
static_assert(sizeof(UParticleModuleColorScaleOverLife) == 0x0000C8, "Wrong size on UParticleModuleColorScaleOverLife");
static_assert(offsetof(UParticleModuleColorScaleOverLife, ColorScaleOverLife) == 0x000030, "Member 'UParticleModuleColorScaleOverLife::ColorScaleOverLife' has a wrong offset!");
static_assert(offsetof(UParticleModuleColorScaleOverLife, AlphaScaleOverLife) == 0x000090, "Member 'UParticleModuleColorScaleOverLife::AlphaScaleOverLife' has a wrong offset!");

// Class Engine.MaterialExpressionSmoothStep
// 0x0088 (0x0138 - 0x00B0)
class UMaterialExpressionSmoothStep final : public UMaterialExpression
{
public:
	struct FExpressionInput                       Min;                                               // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       Max;                                               // 0x00D8(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       Value;                                             // 0x0100(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	float                                         ConstMin;                                          // 0x0128(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         ConstMax;                                          // 0x012C(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         ConstValue;                                        // 0x0130(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_134[0x4];                                      // 0x0134(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionSmoothStep">();
	}
	static class UMaterialExpressionSmoothStep* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionSmoothStep>();
	}
};
static_assert(alignof(UMaterialExpressionSmoothStep) == 0x000008, "Wrong alignment on UMaterialExpressionSmoothStep");
static_assert(sizeof(UMaterialExpressionSmoothStep) == 0x000138, "Wrong size on UMaterialExpressionSmoothStep");
static_assert(offsetof(UMaterialExpressionSmoothStep, Min) == 0x0000B0, "Member 'UMaterialExpressionSmoothStep::Min' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionSmoothStep, Max) == 0x0000D8, "Member 'UMaterialExpressionSmoothStep::Max' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionSmoothStep, Value) == 0x000100, "Member 'UMaterialExpressionSmoothStep::Value' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionSmoothStep, ConstMin) == 0x000128, "Member 'UMaterialExpressionSmoothStep::ConstMin' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionSmoothStep, ConstMax) == 0x00012C, "Member 'UMaterialExpressionSmoothStep::ConstMax' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionSmoothStep, ConstValue) == 0x000130, "Member 'UMaterialExpressionSmoothStep::ConstValue' has a wrong offset!");

// Class Engine.MaterialExpressionSobol
// 0x0090 (0x0140 - 0x00B0)
class UMaterialExpressionSobol final : public UMaterialExpression
{
public:
	struct FExpressionInput                       cell;                                              // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       Index_0;                                           // 0x00D8(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       Seed;                                              // 0x0100(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	uint32                                        ConstIndex;                                        // 0x0128(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_12C[0x4];                                      // 0x012C(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	struct FVector2D                              ConstSeed;                                         // 0x0130(0x0010)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionSobol">();
	}
	static class UMaterialExpressionSobol* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionSobol>();
	}
};
static_assert(alignof(UMaterialExpressionSobol) == 0x000008, "Wrong alignment on UMaterialExpressionSobol");
static_assert(sizeof(UMaterialExpressionSobol) == 0x000140, "Wrong size on UMaterialExpressionSobol");
static_assert(offsetof(UMaterialExpressionSobol, cell) == 0x0000B0, "Member 'UMaterialExpressionSobol::cell' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionSobol, Index_0) == 0x0000D8, "Member 'UMaterialExpressionSobol::Index_0' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionSobol, Seed) == 0x000100, "Member 'UMaterialExpressionSobol::Seed' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionSobol, ConstIndex) == 0x000128, "Member 'UMaterialExpressionSobol::ConstIndex' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionSobol, ConstSeed) == 0x000130, "Member 'UMaterialExpressionSobol::ConstSeed' has a wrong offset!");

// Class Engine.HLODEngineSubsystem
// 0x0000 (0x0030 - 0x0030)
class UHLODEngineSubsystem final : public UEngineSubsystem
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"HLODEngineSubsystem">();
	}
	static class UHLODEngineSubsystem* GetDefaultObj()
	{
		return GetDefaultObjImpl<UHLODEngineSubsystem>();
	}
};
static_assert(alignof(UHLODEngineSubsystem) == 0x000008, "Wrong alignment on UHLODEngineSubsystem");
static_assert(sizeof(UHLODEngineSubsystem) == 0x000030, "Wrong size on UHLODEngineSubsystem");

// Class Engine.MaterialExpressionSparseVolumeTextureObject
// 0x0000 (0x00B8 - 0x00B8)
class UMaterialExpressionSparseVolumeTextureObject final : public UMaterialExpressionSparseVolumeTextureBase
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionSparseVolumeTextureObject">();
	}
	static class UMaterialExpressionSparseVolumeTextureObject* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionSparseVolumeTextureObject>();
	}
};
static_assert(alignof(UMaterialExpressionSparseVolumeTextureObject) == 0x000008, "Wrong alignment on UMaterialExpressionSparseVolumeTextureObject");
static_assert(sizeof(UMaterialExpressionSparseVolumeTextureObject) == 0x0000B8, "Wrong size on UMaterialExpressionSparseVolumeTextureObject");

// Class Engine.ParticleModuleBeamModifier
// 0x0108 (0x0138 - 0x0030)
class UParticleModuleBeamModifier final : public UParticleModuleBeamBase
{
public:
	EBeamModifierType                             ModifierType;                                      // 0x0030(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_31[0x3];                                       // 0x0031(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	struct FBeamModifierOptions                   PositionOptions;                                   // 0x0034(0x0004)(Edit, NoDestructor, NativeAccessSpecifierPublic)
	struct FRawDistributionVector                 position;                                          // 0x0038(0x0060)(Edit, ContainsInstancedReference, NativeAccessSpecifierPublic)
	struct FBeamModifierOptions                   TangentOptions;                                    // 0x0098(0x0004)(Edit, NoDestructor, NativeAccessSpecifierPublic)
	uint8                                         Pad_9C[0x4];                                       // 0x009C(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	struct FRawDistributionVector                 Tangent;                                           // 0x00A0(0x0060)(Edit, ContainsInstancedReference, NativeAccessSpecifierPublic)
	uint8                                         bAbsoluteTangent : 1;                              // 0x0100(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_101[0x3];                                      // 0x0101(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	struct FBeamModifierOptions                   StrengthOptions;                                   // 0x0104(0x0004)(Edit, NoDestructor, NativeAccessSpecifierPublic)
	struct FRawDistributionFloat                  Strength;                                          // 0x0108(0x0030)(Edit, ContainsInstancedReference, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ParticleModuleBeamModifier">();
	}
	static class UParticleModuleBeamModifier* GetDefaultObj()
	{
		return GetDefaultObjImpl<UParticleModuleBeamModifier>();
	}
};
static_assert(alignof(UParticleModuleBeamModifier) == 0x000008, "Wrong alignment on UParticleModuleBeamModifier");
static_assert(sizeof(UParticleModuleBeamModifier) == 0x000138, "Wrong size on UParticleModuleBeamModifier");
static_assert(offsetof(UParticleModuleBeamModifier, ModifierType) == 0x000030, "Member 'UParticleModuleBeamModifier::ModifierType' has a wrong offset!");
static_assert(offsetof(UParticleModuleBeamModifier, PositionOptions) == 0x000034, "Member 'UParticleModuleBeamModifier::PositionOptions' has a wrong offset!");
static_assert(offsetof(UParticleModuleBeamModifier, position) == 0x000038, "Member 'UParticleModuleBeamModifier::position' has a wrong offset!");
static_assert(offsetof(UParticleModuleBeamModifier, TangentOptions) == 0x000098, "Member 'UParticleModuleBeamModifier::TangentOptions' has a wrong offset!");
static_assert(offsetof(UParticleModuleBeamModifier, Tangent) == 0x0000A0, "Member 'UParticleModuleBeamModifier::Tangent' has a wrong offset!");
static_assert(offsetof(UParticleModuleBeamModifier, StrengthOptions) == 0x000104, "Member 'UParticleModuleBeamModifier::StrengthOptions' has a wrong offset!");
static_assert(offsetof(UParticleModuleBeamModifier, Strength) == 0x000108, "Member 'UParticleModuleBeamModifier::Strength' has a wrong offset!");

// Class Engine.MaterialExpressionSparseVolumeTextureSample
// 0x0080 (0x0138 - 0x00B8)
class UMaterialExpressionSparseVolumeTextureSample : public UMaterialExpressionSparseVolumeTextureBase
{
public:
	struct FExpressionInput                       Coordinates;                                       // 0x00B8(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       TextureObject;                                     // 0x00E0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       MipLevel;                                          // 0x0108(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	ESamplerSourceMode                            SamplerSource;                                     // 0x0130(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_131[0x7];                                      // 0x0131(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionSparseVolumeTextureSample">();
	}
	static class UMaterialExpressionSparseVolumeTextureSample* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionSparseVolumeTextureSample>();
	}
};
static_assert(alignof(UMaterialExpressionSparseVolumeTextureSample) == 0x000008, "Wrong alignment on UMaterialExpressionSparseVolumeTextureSample");
static_assert(sizeof(UMaterialExpressionSparseVolumeTextureSample) == 0x000138, "Wrong size on UMaterialExpressionSparseVolumeTextureSample");
static_assert(offsetof(UMaterialExpressionSparseVolumeTextureSample, Coordinates) == 0x0000B8, "Member 'UMaterialExpressionSparseVolumeTextureSample::Coordinates' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionSparseVolumeTextureSample, TextureObject) == 0x0000E0, "Member 'UMaterialExpressionSparseVolumeTextureSample::TextureObject' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionSparseVolumeTextureSample, MipLevel) == 0x000108, "Member 'UMaterialExpressionSparseVolumeTextureSample::MipLevel' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionSparseVolumeTextureSample, SamplerSource) == 0x000130, "Member 'UMaterialExpressionSparseVolumeTextureSample::SamplerSource' has a wrong offset!");

// Class Engine.MaterialExpressionSparseVolumeTextureSampleParameter
// 0x0028 (0x0160 - 0x0138)
class UMaterialExpressionSparseVolumeTextureSampleParameter : public UMaterialExpressionSparseVolumeTextureSample
{
public:
	class FName                                   ParameterName;                                     // 0x0138(0x0008)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FGuid                                  ExpressionGUID;                                    // 0x0140(0x0010)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FName                                   Group;                                             // 0x0150(0x0008)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         SortPriority;                                      // 0x0158(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_15C[0x4];                                      // 0x015C(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionSparseVolumeTextureSampleParameter">();
	}
	static class UMaterialExpressionSparseVolumeTextureSampleParameter* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionSparseVolumeTextureSampleParameter>();
	}
};
static_assert(alignof(UMaterialExpressionSparseVolumeTextureSampleParameter) == 0x000008, "Wrong alignment on UMaterialExpressionSparseVolumeTextureSampleParameter");
static_assert(sizeof(UMaterialExpressionSparseVolumeTextureSampleParameter) == 0x000160, "Wrong size on UMaterialExpressionSparseVolumeTextureSampleParameter");
static_assert(offsetof(UMaterialExpressionSparseVolumeTextureSampleParameter, ParameterName) == 0x000138, "Member 'UMaterialExpressionSparseVolumeTextureSampleParameter::ParameterName' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionSparseVolumeTextureSampleParameter, ExpressionGUID) == 0x000140, "Member 'UMaterialExpressionSparseVolumeTextureSampleParameter::ExpressionGUID' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionSparseVolumeTextureSampleParameter, Group) == 0x000150, "Member 'UMaterialExpressionSparseVolumeTextureSampleParameter::Group' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionSparseVolumeTextureSampleParameter, SortPriority) == 0x000158, "Member 'UMaterialExpressionSparseVolumeTextureSampleParameter::SortPriority' has a wrong offset!");

// Class Engine.InputDelegateBinding
// 0x0000 (0x0028 - 0x0028)
class UInputDelegateBinding : public UDynamicBlueprintBinding
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"InputDelegateBinding">();
	}
	static class UInputDelegateBinding* GetDefaultObj()
	{
		return GetDefaultObjImpl<UInputDelegateBinding>();
	}
};
static_assert(alignof(UInputDelegateBinding) == 0x000008, "Wrong alignment on UInputDelegateBinding");
static_assert(sizeof(UInputDelegateBinding) == 0x000028, "Wrong size on UInputDelegateBinding");

// Class Engine.MaterialExpressionSparseVolumeTextureObjectParameter
// 0x0000 (0x0160 - 0x0160)
class UMaterialExpressionSparseVolumeTextureObjectParameter final : public UMaterialExpressionSparseVolumeTextureSampleParameter
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionSparseVolumeTextureObjectParameter">();
	}
	static class UMaterialExpressionSparseVolumeTextureObjectParameter* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionSparseVolumeTextureObjectParameter>();
	}
};
static_assert(alignof(UMaterialExpressionSparseVolumeTextureObjectParameter) == 0x000008, "Wrong alignment on UMaterialExpressionSparseVolumeTextureObjectParameter");
static_assert(sizeof(UMaterialExpressionSparseVolumeTextureObjectParameter) == 0x000160, "Wrong size on UMaterialExpressionSparseVolumeTextureObjectParameter");

// Class Engine.MaterialExpressionSpeedTree
// 0x00B0 (0x0160 - 0x00B0)
class UMaterialExpressionSpeedTree final : public UMaterialExpression
{
public:
	struct FExpressionInput                       GeometryInput;                                     // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       WindInput;                                         // 0x00D8(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       LODInput;                                          // 0x0100(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       ExtraBendWS;                                       // 0x0128(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	ESpeedTreeGeometryType                        GeometryType;                                      // 0x0150(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	ESpeedTreeWindType                            WindType;                                          // 0x0151(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	ESpeedTreeLODType                             LODType;                                           // 0x0152(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_153[0x1];                                      // 0x0153(0x0001)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         BillboardThreshold;                                // 0x0154(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bAccurateWindVelocities;                           // 0x0158(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_159[0x7];                                      // 0x0159(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionSpeedTree">();
	}
	static class UMaterialExpressionSpeedTree* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionSpeedTree>();
	}
};
static_assert(alignof(UMaterialExpressionSpeedTree) == 0x000008, "Wrong alignment on UMaterialExpressionSpeedTree");
static_assert(sizeof(UMaterialExpressionSpeedTree) == 0x000160, "Wrong size on UMaterialExpressionSpeedTree");
static_assert(offsetof(UMaterialExpressionSpeedTree, GeometryInput) == 0x0000B0, "Member 'UMaterialExpressionSpeedTree::GeometryInput' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionSpeedTree, WindInput) == 0x0000D8, "Member 'UMaterialExpressionSpeedTree::WindInput' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionSpeedTree, LODInput) == 0x000100, "Member 'UMaterialExpressionSpeedTree::LODInput' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionSpeedTree, ExtraBendWS) == 0x000128, "Member 'UMaterialExpressionSpeedTree::ExtraBendWS' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionSpeedTree, GeometryType) == 0x000150, "Member 'UMaterialExpressionSpeedTree::GeometryType' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionSpeedTree, WindType) == 0x000151, "Member 'UMaterialExpressionSpeedTree::WindType' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionSpeedTree, LODType) == 0x000152, "Member 'UMaterialExpressionSpeedTree::LODType' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionSpeedTree, BillboardThreshold) == 0x000154, "Member 'UMaterialExpressionSpeedTree::BillboardThreshold' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionSpeedTree, bAccurateWindVelocities) == 0x000158, "Member 'UMaterialExpressionSpeedTree::bAccurateWindVelocities' has a wrong offset!");

// Class Engine.MaterialExpressionSphereMask
// 0x00A8 (0x0158 - 0x00B0)
class UMaterialExpressionSphereMask final : public UMaterialExpression
{
public:
	struct FExpressionInput                       A;                                                 // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       B;                                                 // 0x00D8(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       Radius;                                            // 0x0100(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       Hardness;                                          // 0x0128(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	float                                         AttenuationRadius;                                 // 0x0150(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         HardnessPercent;                                   // 0x0154(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionSphereMask">();
	}
	static class UMaterialExpressionSphereMask* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionSphereMask>();
	}
};
static_assert(alignof(UMaterialExpressionSphereMask) == 0x000008, "Wrong alignment on UMaterialExpressionSphereMask");
static_assert(sizeof(UMaterialExpressionSphereMask) == 0x000158, "Wrong size on UMaterialExpressionSphereMask");
static_assert(offsetof(UMaterialExpressionSphereMask, A) == 0x0000B0, "Member 'UMaterialExpressionSphereMask::A' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionSphereMask, B) == 0x0000D8, "Member 'UMaterialExpressionSphereMask::B' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionSphereMask, Radius) == 0x000100, "Member 'UMaterialExpressionSphereMask::Radius' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionSphereMask, Hardness) == 0x000128, "Member 'UMaterialExpressionSphereMask::Hardness' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionSphereMask, AttenuationRadius) == 0x000150, "Member 'UMaterialExpressionSphereMask::AttenuationRadius' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionSphereMask, HardnessPercent) == 0x000154, "Member 'UMaterialExpressionSphereMask::HardnessPercent' has a wrong offset!");

// Class Engine.MaterialExpressionSphericalParticleOpacity
// 0x0030 (0x00E0 - 0x00B0)
class UMaterialExpressionSphericalParticleOpacity final : public UMaterialExpression
{
public:
	struct FExpressionInput                       Density;                                           // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	float                                         ConstantDensity;                                   // 0x00D8(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_DC[0x4];                                       // 0x00DC(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionSphericalParticleOpacity">();
	}
	static class UMaterialExpressionSphericalParticleOpacity* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionSphericalParticleOpacity>();
	}
};
static_assert(alignof(UMaterialExpressionSphericalParticleOpacity) == 0x000008, "Wrong alignment on UMaterialExpressionSphericalParticleOpacity");
static_assert(sizeof(UMaterialExpressionSphericalParticleOpacity) == 0x0000E0, "Wrong size on UMaterialExpressionSphericalParticleOpacity");
static_assert(offsetof(UMaterialExpressionSphericalParticleOpacity, Density) == 0x0000B0, "Member 'UMaterialExpressionSphericalParticleOpacity::Density' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionSphericalParticleOpacity, ConstantDensity) == 0x0000D8, "Member 'UMaterialExpressionSphericalParticleOpacity::ConstantDensity' has a wrong offset!");

// Class Engine.InputDeviceLibrary
// 0x0000 (0x0028 - 0x0028)
class UInputDeviceLibrary final : public UBlueprintFunctionLibrary
{
public:
	static bool EqualEqual_InputDeviceId(const struct FInputDeviceId& A, const struct FInputDeviceId& B);
	static bool EqualEqual_PlatformUserId(const struct FPlatformUserId& A, const struct FPlatformUserId& B);
	static int32 GetAllActiveUsers(TArray<struct FPlatformUserId>* OutUsers);
	static int32 GetAllConnectedInputDevices(TArray<struct FInputDeviceId>* OutInputDevices);
	static int32 GetAllInputDevices(TArray<struct FInputDeviceId>* OutInputDevices);
	static int32 GetAllInputDevicesForUser(const struct FPlatformUserId& UserId, TArray<struct FInputDeviceId>* OutInputDevices);
	static struct FInputDeviceId GetDefaultInputDevice();
	static EInputDeviceConnectionState GetInputDeviceConnectionState(const struct FInputDeviceId& DeviceID);
	static class APlayerController* GetPlayerControllerFromInputDevice(const struct FInputDeviceId& DeviceID);
	static class APlayerController* GetPlayerControllerFromPlatformUser(const struct FPlatformUserId& UserId);
	static struct FInputDeviceId GetPrimaryInputDeviceForUser(const struct FPlatformUserId& UserId);
	static struct FPlatformUserId GetPrimaryPlatformUser();
	static struct FPlatformUserId GetUserForInputDevice(const struct FInputDeviceId& DeviceID);
	static struct FPlatformUserId GetUserForUnpairedInputDevices();
	static struct FInputDeviceId InputDeviceId_None();
	static bool IsDevicePropertyHandleValid(const struct FInputDevicePropertyHandle& InHandle);
	static bool IsInputDeviceMappedToUnpairedUser(const struct FInputDeviceId& InputDevice);
	static bool IsUnpairedUserId(const struct FPlatformUserId& PlatformId);
	static bool IsValidInputDevice(const struct FInputDeviceId& DeviceID);
	static bool IsValidPlatformId(const struct FPlatformUserId& UserId);
	static bool NotEqual_InputDeviceId(const struct FInputDeviceId& A, const struct FInputDeviceId& B);
	static bool NotEqual_PlatformUserId(const struct FPlatformUserId& A, const struct FPlatformUserId& B);
	static struct FPlatformUserId PlatformUserId_None();

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"InputDeviceLibrary">();
	}
	static class UInputDeviceLibrary* GetDefaultObj()
	{
		return GetDefaultObjImpl<UInputDeviceLibrary>();
	}
};
static_assert(alignof(UInputDeviceLibrary) == 0x000008, "Wrong alignment on UInputDeviceLibrary");
static_assert(sizeof(UInputDeviceLibrary) == 0x000028, "Wrong size on UInputDeviceLibrary");

// Class Engine.MaterialExpressionStaticBool
// 0x0008 (0x00B8 - 0x00B0)
class UMaterialExpressionStaticBool final : public UMaterialExpression
{
public:
	uint8                                         Value : 1;                                         // 0x00B0(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_B1[0x7];                                       // 0x00B1(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionStaticBool">();
	}
	static class UMaterialExpressionStaticBool* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionStaticBool>();
	}
};
static_assert(alignof(UMaterialExpressionStaticBool) == 0x000008, "Wrong alignment on UMaterialExpressionStaticBool");
static_assert(sizeof(UMaterialExpressionStaticBool) == 0x0000B8, "Wrong size on UMaterialExpressionStaticBool");

// Class Engine.ParticleModuleCollisionGPU
// 0x0078 (0x00A8 - 0x0030)
class UParticleModuleCollisionGPU final : public UParticleModuleCollisionBase
{
public:
	struct FRawDistributionFloat                  Resilience;                                        // 0x0030(0x0030)(Edit, ContainsInstancedReference, NativeAccessSpecifierPublic)
	struct FRawDistributionFloat                  ResilienceScaleOverLife;                           // 0x0060(0x0030)(Edit, ContainsInstancedReference, NativeAccessSpecifierPublic)
	float                                         Friction;                                          // 0x0090(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         RandomSpread;                                      // 0x0094(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         RandomDistribution;                                // 0x0098(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         RadiusScale;                                       // 0x009C(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         RadiusBias;                                        // 0x00A0(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EParticleCollisionResponse                    Response;                                          // 0x00A4(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EParticleCollisionMode                        CollisionMode;                                     // 0x00A5(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_A6[0x2];                                       // 0x00A6(0x0002)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ParticleModuleCollisionGPU">();
	}
	static class UParticleModuleCollisionGPU* GetDefaultObj()
	{
		return GetDefaultObjImpl<UParticleModuleCollisionGPU>();
	}
};
static_assert(alignof(UParticleModuleCollisionGPU) == 0x000008, "Wrong alignment on UParticleModuleCollisionGPU");
static_assert(sizeof(UParticleModuleCollisionGPU) == 0x0000A8, "Wrong size on UParticleModuleCollisionGPU");
static_assert(offsetof(UParticleModuleCollisionGPU, Resilience) == 0x000030, "Member 'UParticleModuleCollisionGPU::Resilience' has a wrong offset!");
static_assert(offsetof(UParticleModuleCollisionGPU, ResilienceScaleOverLife) == 0x000060, "Member 'UParticleModuleCollisionGPU::ResilienceScaleOverLife' has a wrong offset!");
static_assert(offsetof(UParticleModuleCollisionGPU, Friction) == 0x000090, "Member 'UParticleModuleCollisionGPU::Friction' has a wrong offset!");
static_assert(offsetof(UParticleModuleCollisionGPU, RandomSpread) == 0x000094, "Member 'UParticleModuleCollisionGPU::RandomSpread' has a wrong offset!");
static_assert(offsetof(UParticleModuleCollisionGPU, RandomDistribution) == 0x000098, "Member 'UParticleModuleCollisionGPU::RandomDistribution' has a wrong offset!");
static_assert(offsetof(UParticleModuleCollisionGPU, RadiusScale) == 0x00009C, "Member 'UParticleModuleCollisionGPU::RadiusScale' has a wrong offset!");
static_assert(offsetof(UParticleModuleCollisionGPU, RadiusBias) == 0x0000A0, "Member 'UParticleModuleCollisionGPU::RadiusBias' has a wrong offset!");
static_assert(offsetof(UParticleModuleCollisionGPU, Response) == 0x0000A4, "Member 'UParticleModuleCollisionGPU::Response' has a wrong offset!");
static_assert(offsetof(UParticleModuleCollisionGPU, CollisionMode) == 0x0000A5, "Member 'UParticleModuleCollisionGPU::CollisionMode' has a wrong offset!");

// Class Engine.MaterialExpressionStaticBoolParameter
// 0x0008 (0x00E0 - 0x00D8)
class UMaterialExpressionStaticBoolParameter : public UMaterialExpressionParameter
{
public:
	uint8                                         DefaultValue : 1;                                  // 0x00D8(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         DynamicBranch : 1;                                 // 0x00D8(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_D9[0x7];                                       // 0x00D9(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionStaticBoolParameter">();
	}
	static class UMaterialExpressionStaticBoolParameter* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionStaticBoolParameter>();
	}
};
static_assert(alignof(UMaterialExpressionStaticBoolParameter) == 0x000008, "Wrong alignment on UMaterialExpressionStaticBoolParameter");
static_assert(sizeof(UMaterialExpressionStaticBoolParameter) == 0x0000E0, "Wrong size on UMaterialExpressionStaticBoolParameter");

// Class Engine.MaterialExpressionStaticSwitch
// 0x0080 (0x0130 - 0x00B0)
class UMaterialExpressionStaticSwitch final : public UMaterialExpression
{
public:
	uint8                                         DefaultValue : 1;                                  // 0x00B0(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_B1[0x7];                                       // 0x00B1(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	struct FExpressionInput                       A;                                                 // 0x00B8(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       B;                                                 // 0x00E0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       Value;                                             // 0x0108(0x0028)(NoDestructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionStaticSwitch">();
	}
	static class UMaterialExpressionStaticSwitch* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionStaticSwitch>();
	}
};
static_assert(alignof(UMaterialExpressionStaticSwitch) == 0x000008, "Wrong alignment on UMaterialExpressionStaticSwitch");
static_assert(sizeof(UMaterialExpressionStaticSwitch) == 0x000130, "Wrong size on UMaterialExpressionStaticSwitch");
static_assert(offsetof(UMaterialExpressionStaticSwitch, A) == 0x0000B8, "Member 'UMaterialExpressionStaticSwitch::A' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionStaticSwitch, B) == 0x0000E0, "Member 'UMaterialExpressionStaticSwitch::B' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionStaticSwitch, Value) == 0x000108, "Member 'UMaterialExpressionStaticSwitch::Value' has a wrong offset!");

// Class Engine.MaterialExpressionStaticSwitchParameter
// 0x0050 (0x0130 - 0x00E0)
class UMaterialExpressionStaticSwitchParameter final : public UMaterialExpressionStaticBoolParameter
{
public:
	struct FExpressionInput                       A;                                                 // 0x00E0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       B;                                                 // 0x0108(0x0028)(NoDestructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionStaticSwitchParameter">();
	}
	static class UMaterialExpressionStaticSwitchParameter* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionStaticSwitchParameter>();
	}
};
static_assert(alignof(UMaterialExpressionStaticSwitchParameter) == 0x000008, "Wrong alignment on UMaterialExpressionStaticSwitchParameter");
static_assert(sizeof(UMaterialExpressionStaticSwitchParameter) == 0x000130, "Wrong size on UMaterialExpressionStaticSwitchParameter");
static_assert(offsetof(UMaterialExpressionStaticSwitchParameter, A) == 0x0000E0, "Member 'UMaterialExpressionStaticSwitchParameter::A' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionStaticSwitchParameter, B) == 0x000108, "Member 'UMaterialExpressionStaticSwitchParameter::B' has a wrong offset!");

// Class Engine.MaterialExpressionStrataLegacyConversion
// 0x0360 (0x0410 - 0x00B0)
class UMaterialExpressionStrataLegacyConversion final : public UMaterialExpressionStrataBSDF
{
public:
	struct FExpressionInput                       BaseColor;                                         // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       Metallic;                                          // 0x00D8(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       Specular;                                          // 0x0100(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       Roughness;                                         // 0x0128(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       Anisotropy;                                        // 0x0150(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       EmissiveColor;                                     // 0x0178(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       Normal;                                            // 0x01A0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       Tangent;                                           // 0x01C8(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       SubsurfaceColor;                                   // 0x01F0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       ClearCoat;                                         // 0x0218(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       ClearCoatRoughness;                                // 0x0240(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       Opacity;                                           // 0x0268(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       TransmittanceColor;                                // 0x0290(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       WaterScatteringCoefficients;                       // 0x02B8(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       WaterAbsorptionCoefficients;                       // 0x02E0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       WaterPhaseG;                                       // 0x0308(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       ColorScaleBehindWater;                             // 0x0330(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       ClearCoatNormal;                                   // 0x0358(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       CustomTangent;                                     // 0x0380(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FShadingModelMaterialInput             ShadingModel;                                      // 0x03A8(0x0028)(ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_3D0[0x8];                                      // 0x03D0(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	class USubsurfaceProfile*                     SubsurfaceProfile;                                 // 0x03D8(0x0008)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FStrataMaterialInfo                    ConvertedStrataMaterialInfo;                       // 0x03E0(0x0030)(NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionStrataLegacyConversion">();
	}
	static class UMaterialExpressionStrataLegacyConversion* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionStrataLegacyConversion>();
	}
};
static_assert(alignof(UMaterialExpressionStrataLegacyConversion) == 0x000008, "Wrong alignment on UMaterialExpressionStrataLegacyConversion");
static_assert(sizeof(UMaterialExpressionStrataLegacyConversion) == 0x000410, "Wrong size on UMaterialExpressionStrataLegacyConversion");
static_assert(offsetof(UMaterialExpressionStrataLegacyConversion, BaseColor) == 0x0000B0, "Member 'UMaterialExpressionStrataLegacyConversion::BaseColor' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionStrataLegacyConversion, Metallic) == 0x0000D8, "Member 'UMaterialExpressionStrataLegacyConversion::Metallic' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionStrataLegacyConversion, Specular) == 0x000100, "Member 'UMaterialExpressionStrataLegacyConversion::Specular' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionStrataLegacyConversion, Roughness) == 0x000128, "Member 'UMaterialExpressionStrataLegacyConversion::Roughness' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionStrataLegacyConversion, Anisotropy) == 0x000150, "Member 'UMaterialExpressionStrataLegacyConversion::Anisotropy' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionStrataLegacyConversion, EmissiveColor) == 0x000178, "Member 'UMaterialExpressionStrataLegacyConversion::EmissiveColor' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionStrataLegacyConversion, Normal) == 0x0001A0, "Member 'UMaterialExpressionStrataLegacyConversion::Normal' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionStrataLegacyConversion, Tangent) == 0x0001C8, "Member 'UMaterialExpressionStrataLegacyConversion::Tangent' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionStrataLegacyConversion, SubsurfaceColor) == 0x0001F0, "Member 'UMaterialExpressionStrataLegacyConversion::SubsurfaceColor' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionStrataLegacyConversion, ClearCoat) == 0x000218, "Member 'UMaterialExpressionStrataLegacyConversion::ClearCoat' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionStrataLegacyConversion, ClearCoatRoughness) == 0x000240, "Member 'UMaterialExpressionStrataLegacyConversion::ClearCoatRoughness' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionStrataLegacyConversion, Opacity) == 0x000268, "Member 'UMaterialExpressionStrataLegacyConversion::Opacity' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionStrataLegacyConversion, TransmittanceColor) == 0x000290, "Member 'UMaterialExpressionStrataLegacyConversion::TransmittanceColor' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionStrataLegacyConversion, WaterScatteringCoefficients) == 0x0002B8, "Member 'UMaterialExpressionStrataLegacyConversion::WaterScatteringCoefficients' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionStrataLegacyConversion, WaterAbsorptionCoefficients) == 0x0002E0, "Member 'UMaterialExpressionStrataLegacyConversion::WaterAbsorptionCoefficients' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionStrataLegacyConversion, WaterPhaseG) == 0x000308, "Member 'UMaterialExpressionStrataLegacyConversion::WaterPhaseG' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionStrataLegacyConversion, ColorScaleBehindWater) == 0x000330, "Member 'UMaterialExpressionStrataLegacyConversion::ColorScaleBehindWater' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionStrataLegacyConversion, ClearCoatNormal) == 0x000358, "Member 'UMaterialExpressionStrataLegacyConversion::ClearCoatNormal' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionStrataLegacyConversion, CustomTangent) == 0x000380, "Member 'UMaterialExpressionStrataLegacyConversion::CustomTangent' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionStrataLegacyConversion, ShadingModel) == 0x0003A8, "Member 'UMaterialExpressionStrataLegacyConversion::ShadingModel' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionStrataLegacyConversion, SubsurfaceProfile) == 0x0003D8, "Member 'UMaterialExpressionStrataLegacyConversion::SubsurfaceProfile' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionStrataLegacyConversion, ConvertedStrataMaterialInfo) == 0x0003E0, "Member 'UMaterialExpressionStrataLegacyConversion::ConvertedStrataMaterialInfo' has a wrong offset!");

// Class Engine.MaterialExpressionStrataSlabBSDF
// 0x02E8 (0x0398 - 0x00B0)
class UMaterialExpressionStrataSlabBSDF final : public UMaterialExpressionStrataBSDF
{
public:
	struct FExpressionInput                       DiffuseAlbedo;                                     // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       F0;                                                // 0x00D8(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       F90;                                               // 0x0100(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       Roughness;                                         // 0x0128(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       Anisotropy;                                        // 0x0150(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       Normal;                                            // 0x0178(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       Tangent;                                           // 0x01A0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       SSSMFP;                                            // 0x01C8(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       SSSMFPScale;                                       // 0x01F0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       SSSPhaseAnisotropy;                                // 0x0218(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       EmissiveColor;                                     // 0x0240(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       SecondRoughness;                                   // 0x0268(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       SecondRoughnessWeight;                             // 0x0290(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       FuzzRoughness;                                     // 0x02B8(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       FuzzAmount;                                        // 0x02E0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       FuzzColor;                                         // 0x0308(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       GlintValue;                                        // 0x0330(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       GlintUV;                                           // 0x0358(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	class USubsurfaceProfile*                     SubsurfaceProfile;                                 // 0x0380(0x0008)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class USpecularProfile*                       SpecularProfile;                                   // 0x0388(0x0008)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bUseSSSDiffusion : 1;                              // 0x0390(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_391[0x7];                                      // 0x0391(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionStrataSlabBSDF">();
	}
	static class UMaterialExpressionStrataSlabBSDF* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionStrataSlabBSDF>();
	}
};
static_assert(alignof(UMaterialExpressionStrataSlabBSDF) == 0x000008, "Wrong alignment on UMaterialExpressionStrataSlabBSDF");
static_assert(sizeof(UMaterialExpressionStrataSlabBSDF) == 0x000398, "Wrong size on UMaterialExpressionStrataSlabBSDF");
static_assert(offsetof(UMaterialExpressionStrataSlabBSDF, DiffuseAlbedo) == 0x0000B0, "Member 'UMaterialExpressionStrataSlabBSDF::DiffuseAlbedo' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionStrataSlabBSDF, F0) == 0x0000D8, "Member 'UMaterialExpressionStrataSlabBSDF::F0' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionStrataSlabBSDF, F90) == 0x000100, "Member 'UMaterialExpressionStrataSlabBSDF::F90' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionStrataSlabBSDF, Roughness) == 0x000128, "Member 'UMaterialExpressionStrataSlabBSDF::Roughness' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionStrataSlabBSDF, Anisotropy) == 0x000150, "Member 'UMaterialExpressionStrataSlabBSDF::Anisotropy' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionStrataSlabBSDF, Normal) == 0x000178, "Member 'UMaterialExpressionStrataSlabBSDF::Normal' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionStrataSlabBSDF, Tangent) == 0x0001A0, "Member 'UMaterialExpressionStrataSlabBSDF::Tangent' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionStrataSlabBSDF, SSSMFP) == 0x0001C8, "Member 'UMaterialExpressionStrataSlabBSDF::SSSMFP' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionStrataSlabBSDF, SSSMFPScale) == 0x0001F0, "Member 'UMaterialExpressionStrataSlabBSDF::SSSMFPScale' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionStrataSlabBSDF, SSSPhaseAnisotropy) == 0x000218, "Member 'UMaterialExpressionStrataSlabBSDF::SSSPhaseAnisotropy' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionStrataSlabBSDF, EmissiveColor) == 0x000240, "Member 'UMaterialExpressionStrataSlabBSDF::EmissiveColor' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionStrataSlabBSDF, SecondRoughness) == 0x000268, "Member 'UMaterialExpressionStrataSlabBSDF::SecondRoughness' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionStrataSlabBSDF, SecondRoughnessWeight) == 0x000290, "Member 'UMaterialExpressionStrataSlabBSDF::SecondRoughnessWeight' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionStrataSlabBSDF, FuzzRoughness) == 0x0002B8, "Member 'UMaterialExpressionStrataSlabBSDF::FuzzRoughness' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionStrataSlabBSDF, FuzzAmount) == 0x0002E0, "Member 'UMaterialExpressionStrataSlabBSDF::FuzzAmount' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionStrataSlabBSDF, FuzzColor) == 0x000308, "Member 'UMaterialExpressionStrataSlabBSDF::FuzzColor' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionStrataSlabBSDF, GlintValue) == 0x000330, "Member 'UMaterialExpressionStrataSlabBSDF::GlintValue' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionStrataSlabBSDF, GlintUV) == 0x000358, "Member 'UMaterialExpressionStrataSlabBSDF::GlintUV' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionStrataSlabBSDF, SubsurfaceProfile) == 0x000380, "Member 'UMaterialExpressionStrataSlabBSDF::SubsurfaceProfile' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionStrataSlabBSDF, SpecularProfile) == 0x000388, "Member 'UMaterialExpressionStrataSlabBSDF::SpecularProfile' has a wrong offset!");

// Class Engine.MaterialExpressionStrataSimpleClearCoatBSDF
// 0x0118 (0x01C8 - 0x00B0)
class UMaterialExpressionStrataSimpleClearCoatBSDF final : public UMaterialExpressionStrataBSDF
{
public:
	struct FExpressionInput                       DiffuseAlbedo;                                     // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       F0;                                                // 0x00D8(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       Roughness;                                         // 0x0100(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       ClearCoatCoverage;                                 // 0x0128(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       ClearCoatRoughness;                                // 0x0150(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       Normal;                                            // 0x0178(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       EmissiveColor;                                     // 0x01A0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionStrataSimpleClearCoatBSDF">();
	}
	static class UMaterialExpressionStrataSimpleClearCoatBSDF* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionStrataSimpleClearCoatBSDF>();
	}
};
static_assert(alignof(UMaterialExpressionStrataSimpleClearCoatBSDF) == 0x000008, "Wrong alignment on UMaterialExpressionStrataSimpleClearCoatBSDF");
static_assert(sizeof(UMaterialExpressionStrataSimpleClearCoatBSDF) == 0x0001C8, "Wrong size on UMaterialExpressionStrataSimpleClearCoatBSDF");
static_assert(offsetof(UMaterialExpressionStrataSimpleClearCoatBSDF, DiffuseAlbedo) == 0x0000B0, "Member 'UMaterialExpressionStrataSimpleClearCoatBSDF::DiffuseAlbedo' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionStrataSimpleClearCoatBSDF, F0) == 0x0000D8, "Member 'UMaterialExpressionStrataSimpleClearCoatBSDF::F0' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionStrataSimpleClearCoatBSDF, Roughness) == 0x000100, "Member 'UMaterialExpressionStrataSimpleClearCoatBSDF::Roughness' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionStrataSimpleClearCoatBSDF, ClearCoatCoverage) == 0x000128, "Member 'UMaterialExpressionStrataSimpleClearCoatBSDF::ClearCoatCoverage' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionStrataSimpleClearCoatBSDF, ClearCoatRoughness) == 0x000150, "Member 'UMaterialExpressionStrataSimpleClearCoatBSDF::ClearCoatRoughness' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionStrataSimpleClearCoatBSDF, Normal) == 0x000178, "Member 'UMaterialExpressionStrataSimpleClearCoatBSDF::Normal' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionStrataSimpleClearCoatBSDF, EmissiveColor) == 0x0001A0, "Member 'UMaterialExpressionStrataSimpleClearCoatBSDF::EmissiveColor' has a wrong offset!");

// Class Engine.MaterialExpressionStrataUnlitBSDF
// 0x0078 (0x0128 - 0x00B0)
class UMaterialExpressionStrataUnlitBSDF final : public UMaterialExpressionStrataBSDF
{
public:
	struct FExpressionInput                       EmissiveColor;                                     // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       TransmittanceColor;                                // 0x00D8(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       Normal;                                            // 0x0100(0x0028)(NoDestructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionStrataUnlitBSDF">();
	}
	static class UMaterialExpressionStrataUnlitBSDF* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionStrataUnlitBSDF>();
	}
};
static_assert(alignof(UMaterialExpressionStrataUnlitBSDF) == 0x000008, "Wrong alignment on UMaterialExpressionStrataUnlitBSDF");
static_assert(sizeof(UMaterialExpressionStrataUnlitBSDF) == 0x000128, "Wrong size on UMaterialExpressionStrataUnlitBSDF");
static_assert(offsetof(UMaterialExpressionStrataUnlitBSDF, EmissiveColor) == 0x0000B0, "Member 'UMaterialExpressionStrataUnlitBSDF::EmissiveColor' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionStrataUnlitBSDF, TransmittanceColor) == 0x0000D8, "Member 'UMaterialExpressionStrataUnlitBSDF::TransmittanceColor' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionStrataUnlitBSDF, Normal) == 0x000100, "Member 'UMaterialExpressionStrataUnlitBSDF::Normal' has a wrong offset!");

// Class Engine.MaterialExpressionStrataHairBSDF
// 0x0118 (0x01C8 - 0x00B0)
class UMaterialExpressionStrataHairBSDF final : public UMaterialExpressionStrataBSDF
{
public:
	struct FExpressionInput                       BaseColor;                                         // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       Scatter;                                           // 0x00D8(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       Specular;                                          // 0x0100(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       Roughness;                                         // 0x0128(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       Backlit;                                           // 0x0150(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       Tangent;                                           // 0x0178(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       EmissiveColor;                                     // 0x01A0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionStrataHairBSDF">();
	}
	static class UMaterialExpressionStrataHairBSDF* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionStrataHairBSDF>();
	}
};
static_assert(alignof(UMaterialExpressionStrataHairBSDF) == 0x000008, "Wrong alignment on UMaterialExpressionStrataHairBSDF");
static_assert(sizeof(UMaterialExpressionStrataHairBSDF) == 0x0001C8, "Wrong size on UMaterialExpressionStrataHairBSDF");
static_assert(offsetof(UMaterialExpressionStrataHairBSDF, BaseColor) == 0x0000B0, "Member 'UMaterialExpressionStrataHairBSDF::BaseColor' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionStrataHairBSDF, Scatter) == 0x0000D8, "Member 'UMaterialExpressionStrataHairBSDF::Scatter' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionStrataHairBSDF, Specular) == 0x000100, "Member 'UMaterialExpressionStrataHairBSDF::Specular' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionStrataHairBSDF, Roughness) == 0x000128, "Member 'UMaterialExpressionStrataHairBSDF::Roughness' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionStrataHairBSDF, Backlit) == 0x000150, "Member 'UMaterialExpressionStrataHairBSDF::Backlit' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionStrataHairBSDF, Tangent) == 0x000178, "Member 'UMaterialExpressionStrataHairBSDF::Tangent' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionStrataHairBSDF, EmissiveColor) == 0x0001A0, "Member 'UMaterialExpressionStrataHairBSDF::EmissiveColor' has a wrong offset!");

// Class Engine.MaterialExpressionStrataEyeBSDF
// 0x0148 (0x01F8 - 0x00B0)
class UMaterialExpressionStrataEyeBSDF final : public UMaterialExpressionStrataBSDF
{
public:
	struct FExpressionInput                       DiffuseColor;                                      // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       Roughness;                                         // 0x00D8(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       CorneaNormal;                                      // 0x0100(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       IrisNormal;                                        // 0x0128(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       IrisPlaneNormal;                                   // 0x0150(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       IrisMask;                                          // 0x0178(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       IrisDistance;                                      // 0x01A0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       EmissiveColor;                                     // 0x01C8(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	class USubsurfaceProfile*                     SubsurfaceProfile;                                 // 0x01F0(0x0008)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionStrataEyeBSDF">();
	}
	static class UMaterialExpressionStrataEyeBSDF* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionStrataEyeBSDF>();
	}
};
static_assert(alignof(UMaterialExpressionStrataEyeBSDF) == 0x000008, "Wrong alignment on UMaterialExpressionStrataEyeBSDF");
static_assert(sizeof(UMaterialExpressionStrataEyeBSDF) == 0x0001F8, "Wrong size on UMaterialExpressionStrataEyeBSDF");
static_assert(offsetof(UMaterialExpressionStrataEyeBSDF, DiffuseColor) == 0x0000B0, "Member 'UMaterialExpressionStrataEyeBSDF::DiffuseColor' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionStrataEyeBSDF, Roughness) == 0x0000D8, "Member 'UMaterialExpressionStrataEyeBSDF::Roughness' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionStrataEyeBSDF, CorneaNormal) == 0x000100, "Member 'UMaterialExpressionStrataEyeBSDF::CorneaNormal' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionStrataEyeBSDF, IrisNormal) == 0x000128, "Member 'UMaterialExpressionStrataEyeBSDF::IrisNormal' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionStrataEyeBSDF, IrisPlaneNormal) == 0x000150, "Member 'UMaterialExpressionStrataEyeBSDF::IrisPlaneNormal' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionStrataEyeBSDF, IrisMask) == 0x000178, "Member 'UMaterialExpressionStrataEyeBSDF::IrisMask' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionStrataEyeBSDF, IrisDistance) == 0x0001A0, "Member 'UMaterialExpressionStrataEyeBSDF::IrisDistance' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionStrataEyeBSDF, EmissiveColor) == 0x0001C8, "Member 'UMaterialExpressionStrataEyeBSDF::EmissiveColor' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionStrataEyeBSDF, SubsurfaceProfile) == 0x0001F0, "Member 'UMaterialExpressionStrataEyeBSDF::SubsurfaceProfile' has a wrong offset!");

// Class Engine.LevelInstance
// 0x00A0 (0x0340 - 0x02A0)
class ALevelInstance : public AActor
{
public:
	uint8                                         Pad_2A0[0x8];                                      // 0x02A0(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	class ULevelInstanceComponent*                LevelInstanceComponent;                            // 0x02A8(0x0008)(Edit, ExportObject, ZeroConstructor, EditConst, InstancedReference, NoDestructor, Protected, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	TSoftObjectPtr<class UWorld>                  CookedWorldAsset;                                  // 0x02B0(0x0028)(Protected, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	struct FGuid                                  LevelInstanceSpawnGuid;                            // 0x02D8(0x0010)(Net, ZeroConstructor, Transient, IsPlainOldData, RepNotify, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_2E8[0x58];                                     // 0x02E8(0x0058)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void OnRep_LevelInstanceSpawnGuid();

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"LevelInstance">();
	}
	static class ALevelInstance* GetDefaultObj()
	{
		return GetDefaultObjImpl<ALevelInstance>();
	}
};
static_assert(alignof(ALevelInstance) == 0x000008, "Wrong alignment on ALevelInstance");
static_assert(sizeof(ALevelInstance) == 0x000340, "Wrong size on ALevelInstance");
static_assert(offsetof(ALevelInstance, LevelInstanceComponent) == 0x0002A8, "Member 'ALevelInstance::LevelInstanceComponent' has a wrong offset!");
static_assert(offsetof(ALevelInstance, CookedWorldAsset) == 0x0002B0, "Member 'ALevelInstance::CookedWorldAsset' has a wrong offset!");
static_assert(offsetof(ALevelInstance, LevelInstanceSpawnGuid) == 0x0002D8, "Member 'ALevelInstance::LevelInstanceSpawnGuid' has a wrong offset!");

// Class Engine.PackedLevelActor
// 0x0000 (0x0340 - 0x0340)
class APackedLevelActor final : public ALevelInstance
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"PackedLevelActor">();
	}
	static class APackedLevelActor* GetDefaultObj()
	{
		return GetDefaultObjImpl<APackedLevelActor>();
	}
};
static_assert(alignof(APackedLevelActor) == 0x000008, "Wrong alignment on APackedLevelActor");
static_assert(sizeof(APackedLevelActor) == 0x000340, "Wrong size on APackedLevelActor");

// Class Engine.MaterialExpressionStrataSingleLayerWaterBSDF
// 0x01B8 (0x0268 - 0x00B0)
class UMaterialExpressionStrataSingleLayerWaterBSDF final : public UMaterialExpressionStrataBSDF
{
public:
	struct FExpressionInput                       BaseColor;                                         // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       Metallic;                                          // 0x00D8(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       Specular;                                          // 0x0100(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       Roughness;                                         // 0x0128(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       Normal;                                            // 0x0150(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       EmissiveColor;                                     // 0x0178(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       TopMaterialOpacity;                                // 0x01A0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       WaterAlbedo;                                       // 0x01C8(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       WaterExtinction;                                   // 0x01F0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       WaterPhaseG;                                       // 0x0218(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       ColorScaleBehindWater;                             // 0x0240(0x0028)(NoDestructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionStrataSingleLayerWaterBSDF">();
	}
	static class UMaterialExpressionStrataSingleLayerWaterBSDF* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionStrataSingleLayerWaterBSDF>();
	}
};
static_assert(alignof(UMaterialExpressionStrataSingleLayerWaterBSDF) == 0x000008, "Wrong alignment on UMaterialExpressionStrataSingleLayerWaterBSDF");
static_assert(sizeof(UMaterialExpressionStrataSingleLayerWaterBSDF) == 0x000268, "Wrong size on UMaterialExpressionStrataSingleLayerWaterBSDF");
static_assert(offsetof(UMaterialExpressionStrataSingleLayerWaterBSDF, BaseColor) == 0x0000B0, "Member 'UMaterialExpressionStrataSingleLayerWaterBSDF::BaseColor' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionStrataSingleLayerWaterBSDF, Metallic) == 0x0000D8, "Member 'UMaterialExpressionStrataSingleLayerWaterBSDF::Metallic' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionStrataSingleLayerWaterBSDF, Specular) == 0x000100, "Member 'UMaterialExpressionStrataSingleLayerWaterBSDF::Specular' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionStrataSingleLayerWaterBSDF, Roughness) == 0x000128, "Member 'UMaterialExpressionStrataSingleLayerWaterBSDF::Roughness' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionStrataSingleLayerWaterBSDF, Normal) == 0x000150, "Member 'UMaterialExpressionStrataSingleLayerWaterBSDF::Normal' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionStrataSingleLayerWaterBSDF, EmissiveColor) == 0x000178, "Member 'UMaterialExpressionStrataSingleLayerWaterBSDF::EmissiveColor' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionStrataSingleLayerWaterBSDF, TopMaterialOpacity) == 0x0001A0, "Member 'UMaterialExpressionStrataSingleLayerWaterBSDF::TopMaterialOpacity' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionStrataSingleLayerWaterBSDF, WaterAlbedo) == 0x0001C8, "Member 'UMaterialExpressionStrataSingleLayerWaterBSDF::WaterAlbedo' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionStrataSingleLayerWaterBSDF, WaterExtinction) == 0x0001F0, "Member 'UMaterialExpressionStrataSingleLayerWaterBSDF::WaterExtinction' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionStrataSingleLayerWaterBSDF, WaterPhaseG) == 0x000218, "Member 'UMaterialExpressionStrataSingleLayerWaterBSDF::WaterPhaseG' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionStrataSingleLayerWaterBSDF, ColorScaleBehindWater) == 0x000240, "Member 'UMaterialExpressionStrataSingleLayerWaterBSDF::ColorScaleBehindWater' has a wrong offset!");

// Class Engine.MaterialExpressionStrataLightFunction
// 0x0028 (0x00D8 - 0x00B0)
class UMaterialExpressionStrataLightFunction final : public UMaterialExpressionStrataBSDF
{
public:
	struct FExpressionInput                       Color;                                             // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionStrataLightFunction">();
	}
	static class UMaterialExpressionStrataLightFunction* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionStrataLightFunction>();
	}
};
static_assert(alignof(UMaterialExpressionStrataLightFunction) == 0x000008, "Wrong alignment on UMaterialExpressionStrataLightFunction");
static_assert(sizeof(UMaterialExpressionStrataLightFunction) == 0x0000D8, "Wrong size on UMaterialExpressionStrataLightFunction");
static_assert(offsetof(UMaterialExpressionStrataLightFunction, Color) == 0x0000B0, "Member 'UMaterialExpressionStrataLightFunction::Color' has a wrong offset!");

// Class Engine.MaterialExpressionStrataUI
// 0x0050 (0x0100 - 0x00B0)
class UMaterialExpressionStrataUI final : public UMaterialExpressionStrataBSDF
{
public:
	struct FExpressionInput                       Color;                                             // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       Opacity;                                           // 0x00D8(0x0028)(NoDestructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionStrataUI">();
	}
	static class UMaterialExpressionStrataUI* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionStrataUI>();
	}
};
static_assert(alignof(UMaterialExpressionStrataUI) == 0x000008, "Wrong alignment on UMaterialExpressionStrataUI");
static_assert(sizeof(UMaterialExpressionStrataUI) == 0x000100, "Wrong size on UMaterialExpressionStrataUI");
static_assert(offsetof(UMaterialExpressionStrataUI, Color) == 0x0000B0, "Member 'UMaterialExpressionStrataUI::Color' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionStrataUI, Opacity) == 0x0000D8, "Member 'UMaterialExpressionStrataUI::Opacity' has a wrong offset!");

// Class Engine.MaterialExpressionStrataHorizontalMixing
// 0x0080 (0x0130 - 0x00B0)
class UMaterialExpressionStrataHorizontalMixing final : public UMaterialExpressionStrataBSDF
{
public:
	struct FExpressionInput                       Background;                                        // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       Foreground;                                        // 0x00D8(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       Mix;                                               // 0x0100(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	uint8                                         bUseParameterBlending : 1;                         // 0x0128(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_129[0x7];                                      // 0x0129(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionStrataHorizontalMixing">();
	}
	static class UMaterialExpressionStrataHorizontalMixing* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionStrataHorizontalMixing>();
	}
};
static_assert(alignof(UMaterialExpressionStrataHorizontalMixing) == 0x000008, "Wrong alignment on UMaterialExpressionStrataHorizontalMixing");
static_assert(sizeof(UMaterialExpressionStrataHorizontalMixing) == 0x000130, "Wrong size on UMaterialExpressionStrataHorizontalMixing");
static_assert(offsetof(UMaterialExpressionStrataHorizontalMixing, Background) == 0x0000B0, "Member 'UMaterialExpressionStrataHorizontalMixing::Background' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionStrataHorizontalMixing, Foreground) == 0x0000D8, "Member 'UMaterialExpressionStrataHorizontalMixing::Foreground' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionStrataHorizontalMixing, Mix) == 0x000100, "Member 'UMaterialExpressionStrataHorizontalMixing::Mix' has a wrong offset!");

// Class Engine.MaterialExpressionStrataAdd
// 0x0058 (0x0108 - 0x00B0)
class UMaterialExpressionStrataAdd final : public UMaterialExpressionStrataBSDF
{
public:
	struct FExpressionInput                       A;                                                 // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       B;                                                 // 0x00D8(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	uint8                                         bUseParameterBlending : 1;                         // 0x0100(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_101[0x7];                                      // 0x0101(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionStrataAdd">();
	}
	static class UMaterialExpressionStrataAdd* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionStrataAdd>();
	}
};
static_assert(alignof(UMaterialExpressionStrataAdd) == 0x000008, "Wrong alignment on UMaterialExpressionStrataAdd");
static_assert(sizeof(UMaterialExpressionStrataAdd) == 0x000108, "Wrong size on UMaterialExpressionStrataAdd");
static_assert(offsetof(UMaterialExpressionStrataAdd, A) == 0x0000B0, "Member 'UMaterialExpressionStrataAdd::A' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionStrataAdd, B) == 0x0000D8, "Member 'UMaterialExpressionStrataAdd::B' has a wrong offset!");

// Class Engine.MaterialExpressionStrataMetalnessToDiffuseAlbedoF0
// 0x0078 (0x0128 - 0x00B0)
class UMaterialExpressionStrataMetalnessToDiffuseAlbedoF0 final : public UMaterialExpressionStrataUtilityBase
{
public:
	struct FExpressionInput                       BaseColor;                                         // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       Metallic;                                          // 0x00D8(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       Specular;                                          // 0x0100(0x0028)(NoDestructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionStrataMetalnessToDiffuseAlbedoF0">();
	}
	static class UMaterialExpressionStrataMetalnessToDiffuseAlbedoF0* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionStrataMetalnessToDiffuseAlbedoF0>();
	}
};
static_assert(alignof(UMaterialExpressionStrataMetalnessToDiffuseAlbedoF0) == 0x000008, "Wrong alignment on UMaterialExpressionStrataMetalnessToDiffuseAlbedoF0");
static_assert(sizeof(UMaterialExpressionStrataMetalnessToDiffuseAlbedoF0) == 0x000128, "Wrong size on UMaterialExpressionStrataMetalnessToDiffuseAlbedoF0");
static_assert(offsetof(UMaterialExpressionStrataMetalnessToDiffuseAlbedoF0, BaseColor) == 0x0000B0, "Member 'UMaterialExpressionStrataMetalnessToDiffuseAlbedoF0::BaseColor' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionStrataMetalnessToDiffuseAlbedoF0, Metallic) == 0x0000D8, "Member 'UMaterialExpressionStrataMetalnessToDiffuseAlbedoF0::Metallic' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionStrataMetalnessToDiffuseAlbedoF0, Specular) == 0x000100, "Member 'UMaterialExpressionStrataMetalnessToDiffuseAlbedoF0::Specular' has a wrong offset!");

// Class Engine.MaterialExpressionStrataThinFilm
// 0x00C8 (0x0178 - 0x00B0)
class UMaterialExpressionStrataThinFilm final : public UMaterialExpressionStrataUtilityBase
{
public:
	struct FExpressionInput                       Normal;                                            // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       F0;                                                // 0x00D8(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       F90;                                               // 0x0100(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       Thickness;                                         // 0x0128(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       IOR;                                               // 0x0150(0x0028)(NoDestructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionStrataThinFilm">();
	}
	static class UMaterialExpressionStrataThinFilm* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionStrataThinFilm>();
	}
};
static_assert(alignof(UMaterialExpressionStrataThinFilm) == 0x000008, "Wrong alignment on UMaterialExpressionStrataThinFilm");
static_assert(sizeof(UMaterialExpressionStrataThinFilm) == 0x000178, "Wrong size on UMaterialExpressionStrataThinFilm");
static_assert(offsetof(UMaterialExpressionStrataThinFilm, Normal) == 0x0000B0, "Member 'UMaterialExpressionStrataThinFilm::Normal' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionStrataThinFilm, F0) == 0x0000D8, "Member 'UMaterialExpressionStrataThinFilm::F0' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionStrataThinFilm, F90) == 0x000100, "Member 'UMaterialExpressionStrataThinFilm::F90' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionStrataThinFilm, Thickness) == 0x000128, "Member 'UMaterialExpressionStrataThinFilm::Thickness' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionStrataThinFilm, IOR) == 0x000150, "Member 'UMaterialExpressionStrataThinFilm::IOR' has a wrong offset!");

// Class Engine.MaterialExpressionSubtract
// 0x0058 (0x0108 - 0x00B0)
class UMaterialExpressionSubtract final : public UMaterialExpression
{
public:
	struct FExpressionInput                       A;                                                 // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       B;                                                 // 0x00D8(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	float                                         ConstA;                                            // 0x0100(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         ConstB;                                            // 0x0104(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionSubtract">();
	}
	static class UMaterialExpressionSubtract* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionSubtract>();
	}
};
static_assert(alignof(UMaterialExpressionSubtract) == 0x000008, "Wrong alignment on UMaterialExpressionSubtract");
static_assert(sizeof(UMaterialExpressionSubtract) == 0x000108, "Wrong size on UMaterialExpressionSubtract");
static_assert(offsetof(UMaterialExpressionSubtract, A) == 0x0000B0, "Member 'UMaterialExpressionSubtract::A' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionSubtract, B) == 0x0000D8, "Member 'UMaterialExpressionSubtract::B' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionSubtract, ConstA) == 0x000100, "Member 'UMaterialExpressionSubtract::ConstA' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionSubtract, ConstB) == 0x000104, "Member 'UMaterialExpressionSubtract::ConstB' has a wrong offset!");

// Class Engine.SoundNodeWaveParam
// 0x0008 (0x0050 - 0x0048)
class USoundNodeWaveParam final : public USoundNode
{
public:
	class FName                                   WaveParameterName;                                 // 0x0048(0x0008)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"SoundNodeWaveParam">();
	}
	static class USoundNodeWaveParam* GetDefaultObj()
	{
		return GetDefaultObjImpl<USoundNodeWaveParam>();
	}
};
static_assert(alignof(USoundNodeWaveParam) == 0x000008, "Wrong alignment on USoundNodeWaveParam");
static_assert(sizeof(USoundNodeWaveParam) == 0x000050, "Wrong size on USoundNodeWaveParam");
static_assert(offsetof(USoundNodeWaveParam, WaveParameterName) == 0x000048, "Member 'USoundNodeWaveParam::WaveParameterName' has a wrong offset!");

// Class Engine.MaterialExpressionSwitch
// 0x0080 (0x0130 - 0x00B0)
class UMaterialExpressionSwitch final : public UMaterialExpression
{
public:
	class FString                                 Description;                                       // 0x00B0(0x0010)(Edit, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FExpressionInput                       SwitchValue;                                       // 0x00C0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	float                                         ConstSwitchValue;                                  // 0x00E8(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_EC[0x4];                                       // 0x00EC(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	struct FExpressionInput                       Default;                                           // 0x00F0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	float                                         ConstDefault;                                      // 0x0118(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_11C[0x4];                                      // 0x011C(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<struct FSwitchCustomInput>             Inputs;                                            // 0x0120(0x0010)(Edit, ZeroConstructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionSwitch">();
	}
	static class UMaterialExpressionSwitch* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionSwitch>();
	}
};
static_assert(alignof(UMaterialExpressionSwitch) == 0x000008, "Wrong alignment on UMaterialExpressionSwitch");
static_assert(sizeof(UMaterialExpressionSwitch) == 0x000130, "Wrong size on UMaterialExpressionSwitch");
static_assert(offsetof(UMaterialExpressionSwitch, Description) == 0x0000B0, "Member 'UMaterialExpressionSwitch::Description' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionSwitch, SwitchValue) == 0x0000C0, "Member 'UMaterialExpressionSwitch::SwitchValue' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionSwitch, ConstSwitchValue) == 0x0000E8, "Member 'UMaterialExpressionSwitch::ConstSwitchValue' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionSwitch, Default) == 0x0000F0, "Member 'UMaterialExpressionSwitch::Default' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionSwitch, ConstDefault) == 0x000118, "Member 'UMaterialExpressionSwitch::ConstDefault' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionSwitch, Inputs) == 0x000120, "Member 'UMaterialExpressionSwitch::Inputs' has a wrong offset!");

// Class Engine.MaterialExpressionTangent
// 0x0030 (0x00E0 - 0x00B0)
class UMaterialExpressionTangent final : public UMaterialExpression
{
public:
	struct FExpressionInput                       Input;                                             // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	float                                         Period;                                            // 0x00D8(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_DC[0x4];                                       // 0x00DC(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionTangent">();
	}
	static class UMaterialExpressionTangent* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionTangent>();
	}
};
static_assert(alignof(UMaterialExpressionTangent) == 0x000008, "Wrong alignment on UMaterialExpressionTangent");
static_assert(sizeof(UMaterialExpressionTangent) == 0x0000E0, "Wrong size on UMaterialExpressionTangent");
static_assert(offsetof(UMaterialExpressionTangent, Input) == 0x0000B0, "Member 'UMaterialExpressionTangent::Input' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionTangent, Period) == 0x0000D8, "Member 'UMaterialExpressionTangent::Period' has a wrong offset!");

// Class Engine.MaterialExpressionTangentOutput
// 0x0028 (0x00D8 - 0x00B0)
class UMaterialExpressionTangentOutput final : public UMaterialExpressionCustomOutput
{
public:
	struct FExpressionInput                       Input;                                             // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionTangentOutput">();
	}
	static class UMaterialExpressionTangentOutput* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionTangentOutput>();
	}
};
static_assert(alignof(UMaterialExpressionTangentOutput) == 0x000008, "Wrong alignment on UMaterialExpressionTangentOutput");
static_assert(sizeof(UMaterialExpressionTangentOutput) == 0x0000D8, "Wrong size on UMaterialExpressionTangentOutput");
static_assert(offsetof(UMaterialExpressionTangentOutput, Input) == 0x0000B0, "Member 'UMaterialExpressionTangentOutput::Input' has a wrong offset!");

// Class Engine.MaterialExpressionTemporalSobol
// 0x0068 (0x0118 - 0x00B0)
class UMaterialExpressionTemporalSobol final : public UMaterialExpression
{
public:
	struct FExpressionInput                       Index_0;                                           // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       Seed;                                              // 0x00D8(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	uint32                                        ConstIndex;                                        // 0x0100(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_104[0x4];                                      // 0x0104(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	struct FVector2D                              ConstSeed;                                         // 0x0108(0x0010)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionTemporalSobol">();
	}
	static class UMaterialExpressionTemporalSobol* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionTemporalSobol>();
	}
};
static_assert(alignof(UMaterialExpressionTemporalSobol) == 0x000008, "Wrong alignment on UMaterialExpressionTemporalSobol");
static_assert(sizeof(UMaterialExpressionTemporalSobol) == 0x000118, "Wrong size on UMaterialExpressionTemporalSobol");
static_assert(offsetof(UMaterialExpressionTemporalSobol, Index_0) == 0x0000B0, "Member 'UMaterialExpressionTemporalSobol::Index_0' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionTemporalSobol, Seed) == 0x0000D8, "Member 'UMaterialExpressionTemporalSobol::Seed' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionTemporalSobol, ConstIndex) == 0x000100, "Member 'UMaterialExpressionTemporalSobol::ConstIndex' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionTemporalSobol, ConstSeed) == 0x000108, "Member 'UMaterialExpressionTemporalSobol::ConstSeed' has a wrong offset!");

// Class Engine.PhysicsHandleComponent
// 0x0438 (0x04E0 - 0x00A8)
class alignas(0x10) UPhysicsHandleComponent final : public UActorComponent
{
public:
	class UPrimitiveComponent*                    GrabbedComponent;                                  // 0x00A8(0x0008)(ExportObject, ZeroConstructor, InstancedReference, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_B0[0x8];                                       // 0x00B0(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	uint8                                         BitPad_B8_0 : 1;                                   // 0x00B8(0x0001)(Fixing Bit-Field Size Between Bits [ Dumper-7 ])
	uint8                                         bSoftAngularConstraint : 1;                        // 0x00B8(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bSoftLinearConstraint : 1;                         // 0x00B8(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bInterpolateTarget : 1;                            // 0x00B8(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_B9[0x3];                                       // 0x00B9(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         LinearDamping;                                     // 0x00BC(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         LinearStiffness;                                   // 0x00C0(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         AngularDamping;                                    // 0x00C4(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         AngularStiffness;                                  // 0x00C8(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_CC[0xC4];                                      // 0x00CC(0x00C4)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         InterpolationSpeed;                                // 0x0190(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_194[0x34C];                                    // 0x0194(0x034C)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void GrabComponent(class UPrimitiveComponent* Component, class FName InBoneName, const struct FVector& GrabLocation, bool bConstrainRotation);
	void GrabComponentAtLocation(class UPrimitiveComponent* Component, class FName InBoneName, const struct FVector& GrabLocation);
	void GrabComponentAtLocationWithRotation(class UPrimitiveComponent* Component, class FName InBoneName, const struct FVector& Location, const struct FRotator& Rotation);
	void ReleaseComponent();
	void SetAngularDamping(float NewAngularDamping);
	void SetAngularStiffness(float NewAngularStiffness);
	void SetInterpolationSpeed(float NewInterpolationSpeed);
	void SetLinearDamping(float NewLinearDamping);
	void SetLinearStiffness(float NewLinearStiffness);
	void SetTargetLocation(const struct FVector& NewLocation);
	void SetTargetLocationAndRotation(const struct FVector& NewLocation, const struct FRotator& NewRotation);
	void SetTargetRotation(const struct FRotator& NewRotation);

	class UPrimitiveComponent* GetGrabbedComponent() const;
	void GetTargetLocationAndRotation(struct FVector* TargetLocation, struct FRotator* TargetRotation) const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"PhysicsHandleComponent">();
	}
	static class UPhysicsHandleComponent* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPhysicsHandleComponent>();
	}
};
static_assert(alignof(UPhysicsHandleComponent) == 0x000010, "Wrong alignment on UPhysicsHandleComponent");
static_assert(sizeof(UPhysicsHandleComponent) == 0x0004E0, "Wrong size on UPhysicsHandleComponent");
static_assert(offsetof(UPhysicsHandleComponent, GrabbedComponent) == 0x0000A8, "Member 'UPhysicsHandleComponent::GrabbedComponent' has a wrong offset!");
static_assert(offsetof(UPhysicsHandleComponent, LinearDamping) == 0x0000BC, "Member 'UPhysicsHandleComponent::LinearDamping' has a wrong offset!");
static_assert(offsetof(UPhysicsHandleComponent, LinearStiffness) == 0x0000C0, "Member 'UPhysicsHandleComponent::LinearStiffness' has a wrong offset!");
static_assert(offsetof(UPhysicsHandleComponent, AngularDamping) == 0x0000C4, "Member 'UPhysicsHandleComponent::AngularDamping' has a wrong offset!");
static_assert(offsetof(UPhysicsHandleComponent, AngularStiffness) == 0x0000C8, "Member 'UPhysicsHandleComponent::AngularStiffness' has a wrong offset!");
static_assert(offsetof(UPhysicsHandleComponent, InterpolationSpeed) == 0x000190, "Member 'UPhysicsHandleComponent::InterpolationSpeed' has a wrong offset!");

// Class Engine.MaterialExpressionTextureCoordinate
// 0x0010 (0x00C0 - 0x00B0)
class UMaterialExpressionTextureCoordinate final : public UMaterialExpression
{
public:
	int32                                         CoordinateIndex;                                   // 0x00B0(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         UTiling;                                           // 0x00B4(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         VTiling;                                           // 0x00B8(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         UnMirrorU : 1;                                     // 0x00BC(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         UnMirrorV : 1;                                     // 0x00BC(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_BD[0x3];                                       // 0x00BD(0x0003)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionTextureCoordinate">();
	}
	static class UMaterialExpressionTextureCoordinate* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionTextureCoordinate>();
	}
};
static_assert(alignof(UMaterialExpressionTextureCoordinate) == 0x000008, "Wrong alignment on UMaterialExpressionTextureCoordinate");
static_assert(sizeof(UMaterialExpressionTextureCoordinate) == 0x0000C0, "Wrong size on UMaterialExpressionTextureCoordinate");
static_assert(offsetof(UMaterialExpressionTextureCoordinate, CoordinateIndex) == 0x0000B0, "Member 'UMaterialExpressionTextureCoordinate::CoordinateIndex' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionTextureCoordinate, UTiling) == 0x0000B4, "Member 'UMaterialExpressionTextureCoordinate::UTiling' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionTextureCoordinate, VTiling) == 0x0000B8, "Member 'UMaterialExpressionTextureCoordinate::VTiling' has a wrong offset!");

// Class Engine.FXSystemAsset
// 0x0020 (0x0048 - 0x0028)
class UFXSystemAsset : public UObject
{
public:
	uint32                                        MaxPoolSize;                                       // 0x0028(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint32                                        PoolPrimeSize;                                     // 0x002C(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_30[0x18];                                      // 0x0030(0x0018)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"FXSystemAsset">();
	}
	static class UFXSystemAsset* GetDefaultObj()
	{
		return GetDefaultObjImpl<UFXSystemAsset>();
	}
};
static_assert(alignof(UFXSystemAsset) == 0x000008, "Wrong alignment on UFXSystemAsset");
static_assert(sizeof(UFXSystemAsset) == 0x000048, "Wrong size on UFXSystemAsset");
static_assert(offsetof(UFXSystemAsset, MaxPoolSize) == 0x000028, "Member 'UFXSystemAsset::MaxPoolSize' has a wrong offset!");
static_assert(offsetof(UFXSystemAsset, PoolPrimeSize) == 0x00002C, "Member 'UFXSystemAsset::PoolPrimeSize' has a wrong offset!");

// Class Engine.ParticleSystem
// 0x0128 (0x0170 - 0x0048)
class UParticleSystem final : public UFXSystemAsset
{
public:
	float                                         UpdateTime_FPS;                                    // 0x0048(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         UpdateTime_Delta;                                  // 0x004C(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         WarmupTime;                                        // 0x0050(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         WarmupTickRate;                                    // 0x0054(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TArray<class UParticleEmitter*>               Emitters;                                          // 0x0058(0x0010)(ExportObject, ZeroConstructor, ContainsInstancedReference, UObjectWrapper, NativeAccessSpecifierPublic)
	class UParticleSystemComponent*               PreviewComponent;                                  // 0x0068(0x0008)(ExportObject, ZeroConstructor, Transient, InstancedReference, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UInterpCurveEdSetup*                    CurveEdSetup;                                      // 0x0070(0x0008)(ExportObject, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         LODDistanceCheckTime;                              // 0x0078(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, AssetRegistrySearchable, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         MacroUVRadius;                                     // 0x007C(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TArray<float>                                 LODDistances;                                      // 0x0080(0x0010)(Edit, EditFixedSize, ZeroConstructor, NativeAccessSpecifierPublic)
	TArray<struct FParticleSystemLOD>             LODSettings;                                       // 0x0090(0x0010)(Edit, ZeroConstructor, NativeAccessSpecifierPublic)
	struct FBox                                   FixedRelativeBoundingBox;                          // 0x00A0(0x0038)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
	float                                         SecondsBeforeInactive;                             // 0x00D8(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         Delay;                                             // 0x00DC(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, AssetRegistrySearchable, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         DelayLow;                                          // 0x00E0(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bOrientZAxisTowardCamera : 1;                      // 0x00E4(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bUseFixedRelativeBoundingBox : 1;                  // 0x00E4(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bShouldResetPeakCounts : 1;                        // 0x00E4(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bHasPhysics : 1;                                   // 0x00E4(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (Transient, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bUseRealtimeThumbnail : 1;                         // 0x00E4(0x0001)(BitIndex: 0x04, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         ThumbnailImageOutOfDate : 1;                       // 0x00E4(0x0001)(BitIndex: 0x05, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         BitPad_E4_6 : 2;                                   // 0x00E4(0x0001)(Fixing Bit-Field Size For New Byte [ Dumper-7 ])
	uint8                                         bUseDelayRange : 1;                                // 0x00E5(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bAllowManagedTicking : 1;                          // 0x00E5(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bAutoDeactivate : 1;                               // 0x00E5(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bRegenerateLODDuplicate : 1;                       // 0x00E5(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	EParticleSystemUpdateMode                     SystemUpdateMode;                                  // 0x00E6(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, AssetRegistrySearchable, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EParticleSystemLODMethod                      LODMethod;                                         // 0x00E7(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EParticleSystemInsignificanceReaction         InsignificantReaction;                             // 0x00E8(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EParticleSystemOcclusionBoundsMethod          OcclusionBoundsMethod;                             // 0x00E9(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_EA[0x1];                                       // 0x00EA(0x0001)(Fixing Size After Last Property [ Dumper-7 ])
	EParticleSignificanceLevel                    MaxSignificanceLevel;                              // 0x00EB(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint32                                        MinTimeBetweenTicks;                               // 0x00EC(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         InsignificanceDelay;                               // 0x00F0(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_F4[0x4];                                       // 0x00F4(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	struct FVector                                MacroUVPosition;                                   // 0x00F8(0x0018)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FBox                                   CustomOcclusionBounds;                             // 0x0110(0x0038)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
	TArray<struct FLODSoloTrack>                  SoloTracking;                                      // 0x0148(0x0010)(ZeroConstructor, Transient, NativeAccessSpecifierPublic)
	TArray<struct FNamedEmitterMaterial>          NamedMaterialSlots;                                // 0x0158(0x0010)(Edit, ZeroConstructor, NativeAccessSpecifierPublic)
	uint8                                         Pad_168[0x8];                                      // 0x0168(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	bool ContainsEmitterType(class UClass* TypeData);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ParticleSystem">();
	}
	static class UParticleSystem* GetDefaultObj()
	{
		return GetDefaultObjImpl<UParticleSystem>();
	}
};
static_assert(alignof(UParticleSystem) == 0x000008, "Wrong alignment on UParticleSystem");
static_assert(sizeof(UParticleSystem) == 0x000170, "Wrong size on UParticleSystem");
static_assert(offsetof(UParticleSystem, UpdateTime_FPS) == 0x000048, "Member 'UParticleSystem::UpdateTime_FPS' has a wrong offset!");
static_assert(offsetof(UParticleSystem, UpdateTime_Delta) == 0x00004C, "Member 'UParticleSystem::UpdateTime_Delta' has a wrong offset!");
static_assert(offsetof(UParticleSystem, WarmupTime) == 0x000050, "Member 'UParticleSystem::WarmupTime' has a wrong offset!");
static_assert(offsetof(UParticleSystem, WarmupTickRate) == 0x000054, "Member 'UParticleSystem::WarmupTickRate' has a wrong offset!");
static_assert(offsetof(UParticleSystem, Emitters) == 0x000058, "Member 'UParticleSystem::Emitters' has a wrong offset!");
static_assert(offsetof(UParticleSystem, PreviewComponent) == 0x000068, "Member 'UParticleSystem::PreviewComponent' has a wrong offset!");
static_assert(offsetof(UParticleSystem, CurveEdSetup) == 0x000070, "Member 'UParticleSystem::CurveEdSetup' has a wrong offset!");
static_assert(offsetof(UParticleSystem, LODDistanceCheckTime) == 0x000078, "Member 'UParticleSystem::LODDistanceCheckTime' has a wrong offset!");
static_assert(offsetof(UParticleSystem, MacroUVRadius) == 0x00007C, "Member 'UParticleSystem::MacroUVRadius' has a wrong offset!");
static_assert(offsetof(UParticleSystem, LODDistances) == 0x000080, "Member 'UParticleSystem::LODDistances' has a wrong offset!");
static_assert(offsetof(UParticleSystem, LODSettings) == 0x000090, "Member 'UParticleSystem::LODSettings' has a wrong offset!");
static_assert(offsetof(UParticleSystem, FixedRelativeBoundingBox) == 0x0000A0, "Member 'UParticleSystem::FixedRelativeBoundingBox' has a wrong offset!");
static_assert(offsetof(UParticleSystem, SecondsBeforeInactive) == 0x0000D8, "Member 'UParticleSystem::SecondsBeforeInactive' has a wrong offset!");
static_assert(offsetof(UParticleSystem, Delay) == 0x0000DC, "Member 'UParticleSystem::Delay' has a wrong offset!");
static_assert(offsetof(UParticleSystem, DelayLow) == 0x0000E0, "Member 'UParticleSystem::DelayLow' has a wrong offset!");
static_assert(offsetof(UParticleSystem, SystemUpdateMode) == 0x0000E6, "Member 'UParticleSystem::SystemUpdateMode' has a wrong offset!");
static_assert(offsetof(UParticleSystem, LODMethod) == 0x0000E7, "Member 'UParticleSystem::LODMethod' has a wrong offset!");
static_assert(offsetof(UParticleSystem, InsignificantReaction) == 0x0000E8, "Member 'UParticleSystem::InsignificantReaction' has a wrong offset!");
static_assert(offsetof(UParticleSystem, OcclusionBoundsMethod) == 0x0000E9, "Member 'UParticleSystem::OcclusionBoundsMethod' has a wrong offset!");
static_assert(offsetof(UParticleSystem, MaxSignificanceLevel) == 0x0000EB, "Member 'UParticleSystem::MaxSignificanceLevel' has a wrong offset!");
static_assert(offsetof(UParticleSystem, MinTimeBetweenTicks) == 0x0000EC, "Member 'UParticleSystem::MinTimeBetweenTicks' has a wrong offset!");
static_assert(offsetof(UParticleSystem, InsignificanceDelay) == 0x0000F0, "Member 'UParticleSystem::InsignificanceDelay' has a wrong offset!");
static_assert(offsetof(UParticleSystem, MacroUVPosition) == 0x0000F8, "Member 'UParticleSystem::MacroUVPosition' has a wrong offset!");
static_assert(offsetof(UParticleSystem, CustomOcclusionBounds) == 0x000110, "Member 'UParticleSystem::CustomOcclusionBounds' has a wrong offset!");
static_assert(offsetof(UParticleSystem, SoloTracking) == 0x000148, "Member 'UParticleSystem::SoloTracking' has a wrong offset!");
static_assert(offsetof(UParticleSystem, NamedMaterialSlots) == 0x000158, "Member 'UParticleSystem::NamedMaterialSlots' has a wrong offset!");

// Class Engine.MaterialExpressionTextureObject
// 0x0000 (0x00C0 - 0x00C0)
class UMaterialExpressionTextureObject final : public UMaterialExpressionTextureBase
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionTextureObject">();
	}
	static class UMaterialExpressionTextureObject* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionTextureObject>();
	}
};
static_assert(alignof(UMaterialExpressionTextureObject) == 0x000008, "Wrong alignment on UMaterialExpressionTextureObject");
static_assert(sizeof(UMaterialExpressionTextureObject) == 0x0000C0, "Wrong size on UMaterialExpressionTextureObject");

// Class Engine.MaterialExpressionTextureObjectParameter
// 0x0000 (0x0240 - 0x0240)
class UMaterialExpressionTextureObjectParameter final : public UMaterialExpressionTextureSampleParameter
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionTextureObjectParameter">();
	}
	static class UMaterialExpressionTextureObjectParameter* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionTextureObjectParameter>();
	}
};
static_assert(alignof(UMaterialExpressionTextureObjectParameter) == 0x000008, "Wrong alignment on UMaterialExpressionTextureObjectParameter");
static_assert(sizeof(UMaterialExpressionTextureObjectParameter) == 0x000240, "Wrong size on UMaterialExpressionTextureObjectParameter");

// Class Engine.PhysicsFieldComponent
// 0x00E0 (0x0380 - 0x02A0)
class UPhysicsFieldComponent final : public USceneComponent
{
public:
	uint8                                         Pad_2A0[0xE0];                                     // 0x02A0(0x00E0)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"PhysicsFieldComponent">();
	}
	static class UPhysicsFieldComponent* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPhysicsFieldComponent>();
	}
};
static_assert(alignof(UPhysicsFieldComponent) == 0x000010, "Wrong alignment on UPhysicsFieldComponent");
static_assert(sizeof(UPhysicsFieldComponent) == 0x000380, "Wrong size on UPhysicsFieldComponent");

// Class Engine.MaterialExpressionTextureSampleParameter2DArray
// 0x0000 (0x0240 - 0x0240)
class UMaterialExpressionTextureSampleParameter2DArray final : public UMaterialExpressionTextureSampleParameter
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionTextureSampleParameter2DArray">();
	}
	static class UMaterialExpressionTextureSampleParameter2DArray* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionTextureSampleParameter2DArray>();
	}
};
static_assert(alignof(UMaterialExpressionTextureSampleParameter2DArray) == 0x000008, "Wrong alignment on UMaterialExpressionTextureSampleParameter2DArray");
static_assert(sizeof(UMaterialExpressionTextureSampleParameter2DArray) == 0x000240, "Wrong size on UMaterialExpressionTextureSampleParameter2DArray");

// Class Engine.ParticleModuleAccelerationConstant
// 0x0018 (0x0050 - 0x0038)
class UParticleModuleAccelerationConstant final : public UParticleModuleAccelerationBase
{
public:
	struct FVector                                Acceleration;                                      // 0x0038(0x0018)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ParticleModuleAccelerationConstant">();
	}
	static class UParticleModuleAccelerationConstant* GetDefaultObj()
	{
		return GetDefaultObjImpl<UParticleModuleAccelerationConstant>();
	}
};
static_assert(alignof(UParticleModuleAccelerationConstant) == 0x000008, "Wrong alignment on UParticleModuleAccelerationConstant");
static_assert(sizeof(UParticleModuleAccelerationConstant) == 0x000050, "Wrong size on UParticleModuleAccelerationConstant");
static_assert(offsetof(UParticleModuleAccelerationConstant, Acceleration) == 0x000038, "Member 'UParticleModuleAccelerationConstant::Acceleration' has a wrong offset!");

// Class Engine.MaterialExpressionTextureSampleParameterCube
// 0x0000 (0x0240 - 0x0240)
class UMaterialExpressionTextureSampleParameterCube final : public UMaterialExpressionTextureSampleParameter
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionTextureSampleParameterCube">();
	}
	static class UMaterialExpressionTextureSampleParameterCube* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionTextureSampleParameterCube>();
	}
};
static_assert(alignof(UMaterialExpressionTextureSampleParameterCube) == 0x000008, "Wrong alignment on UMaterialExpressionTextureSampleParameterCube");
static_assert(sizeof(UMaterialExpressionTextureSampleParameterCube) == 0x000240, "Wrong size on UMaterialExpressionTextureSampleParameterCube");

// Class Engine.MaterialExpressionTextureSampleParameterCubeArray
// 0x0000 (0x0240 - 0x0240)
class UMaterialExpressionTextureSampleParameterCubeArray final : public UMaterialExpressionTextureSampleParameter
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionTextureSampleParameterCubeArray">();
	}
	static class UMaterialExpressionTextureSampleParameterCubeArray* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionTextureSampleParameterCubeArray>();
	}
};
static_assert(alignof(UMaterialExpressionTextureSampleParameterCubeArray) == 0x000008, "Wrong alignment on UMaterialExpressionTextureSampleParameterCubeArray");
static_assert(sizeof(UMaterialExpressionTextureSampleParameterCubeArray) == 0x000240, "Wrong size on UMaterialExpressionTextureSampleParameterCubeArray");

// Class Engine.ParticleLODLevel
// 0x0090 (0x00B8 - 0x0028)
class UParticleLODLevel final : public UObject
{
public:
	int32                                         Level;                                             // 0x0028(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bEnabled : 1;                                      // 0x002C(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_2D[0x3];                                       // 0x002D(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	class UParticleModuleRequired*                RequiredModule;                                    // 0x0030(0x0008)(ExportObject, ZeroConstructor, InstancedReference, NoDestructor, PersistentInstance, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TArray<class UParticleModule*>                Modules;                                           // 0x0038(0x0010)(ExportObject, ZeroConstructor, ContainsInstancedReference, UObjectWrapper, NativeAccessSpecifierPublic)
	class UParticleModuleTypeDataBase*            TypeDataModule;                                    // 0x0048(0x0008)(ExportObject, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UParticleModuleSpawn*                   SpawnModule;                                       // 0x0050(0x0008)(ExportObject, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UParticleModuleEventGenerator*          EventGenerator;                                    // 0x0058(0x0008)(ExportObject, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TArray<class UParticleModuleSpawnBase*>       SpawningModules;                                   // 0x0060(0x0010)(ZeroConstructor, Transient, DuplicateTransient, UObjectWrapper, NativeAccessSpecifierPublic)
	TArray<class UParticleModule*>                SpawnModules;                                      // 0x0070(0x0010)(ZeroConstructor, Transient, DuplicateTransient, UObjectWrapper, NativeAccessSpecifierPublic)
	TArray<class UParticleModule*>                UpdateModules;                                     // 0x0080(0x0010)(ZeroConstructor, Transient, DuplicateTransient, UObjectWrapper, NativeAccessSpecifierPublic)
	TArray<class UParticleModuleOrbit*>           OrbitModules;                                      // 0x0090(0x0010)(ZeroConstructor, Transient, DuplicateTransient, UObjectWrapper, NativeAccessSpecifierPublic)
	TArray<class UParticleModuleEventReceiverBase*> EventReceiverModules;                            // 0x00A0(0x0010)(ZeroConstructor, Transient, DuplicateTransient, UObjectWrapper, NativeAccessSpecifierPublic)
	uint8                                         ConvertedModules : 1;                              // 0x00B0(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_B1[0x3];                                       // 0x00B1(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	int32                                         PeakActiveParticles;                               // 0x00B4(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ParticleLODLevel">();
	}
	static class UParticleLODLevel* GetDefaultObj()
	{
		return GetDefaultObjImpl<UParticleLODLevel>();
	}
};
static_assert(alignof(UParticleLODLevel) == 0x000008, "Wrong alignment on UParticleLODLevel");
static_assert(sizeof(UParticleLODLevel) == 0x0000B8, "Wrong size on UParticleLODLevel");
static_assert(offsetof(UParticleLODLevel, Level) == 0x000028, "Member 'UParticleLODLevel::Level' has a wrong offset!");
static_assert(offsetof(UParticleLODLevel, RequiredModule) == 0x000030, "Member 'UParticleLODLevel::RequiredModule' has a wrong offset!");
static_assert(offsetof(UParticleLODLevel, Modules) == 0x000038, "Member 'UParticleLODLevel::Modules' has a wrong offset!");
static_assert(offsetof(UParticleLODLevel, TypeDataModule) == 0x000048, "Member 'UParticleLODLevel::TypeDataModule' has a wrong offset!");
static_assert(offsetof(UParticleLODLevel, SpawnModule) == 0x000050, "Member 'UParticleLODLevel::SpawnModule' has a wrong offset!");
static_assert(offsetof(UParticleLODLevel, EventGenerator) == 0x000058, "Member 'UParticleLODLevel::EventGenerator' has a wrong offset!");
static_assert(offsetof(UParticleLODLevel, SpawningModules) == 0x000060, "Member 'UParticleLODLevel::SpawningModules' has a wrong offset!");
static_assert(offsetof(UParticleLODLevel, SpawnModules) == 0x000070, "Member 'UParticleLODLevel::SpawnModules' has a wrong offset!");
static_assert(offsetof(UParticleLODLevel, UpdateModules) == 0x000080, "Member 'UParticleLODLevel::UpdateModules' has a wrong offset!");
static_assert(offsetof(UParticleLODLevel, OrbitModules) == 0x000090, "Member 'UParticleLODLevel::OrbitModules' has a wrong offset!");
static_assert(offsetof(UParticleLODLevel, EventReceiverModules) == 0x0000A0, "Member 'UParticleLODLevel::EventReceiverModules' has a wrong offset!");
static_assert(offsetof(UParticleLODLevel, PeakActiveParticles) == 0x0000B4, "Member 'UParticleLODLevel::PeakActiveParticles' has a wrong offset!");

// Class Engine.MaterialExpressionTextureSampleParameterSubUV
// 0x0008 (0x0248 - 0x0240)
class UMaterialExpressionTextureSampleParameterSubUV final : public UMaterialExpressionTextureSampleParameter2D
{
public:
	uint8                                         bBlend : 1;                                        // 0x0240(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_241[0x7];                                      // 0x0241(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionTextureSampleParameterSubUV">();
	}
	static class UMaterialExpressionTextureSampleParameterSubUV* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionTextureSampleParameterSubUV>();
	}
};
static_assert(alignof(UMaterialExpressionTextureSampleParameterSubUV) == 0x000008, "Wrong alignment on UMaterialExpressionTextureSampleParameterSubUV");
static_assert(sizeof(UMaterialExpressionTextureSampleParameterSubUV) == 0x000248, "Wrong size on UMaterialExpressionTextureSampleParameterSubUV");

// Class Engine.PlayerState
// 0x00B8 (0x0358 - 0x02A0)
class APlayerState final : public AInfo
{
public:
	float                                         Score;                                             // 0x02A0(0x0004)(BlueprintVisible, BlueprintReadOnly, Net, ZeroConstructor, IsPlainOldData, RepNotify, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         PlayerId;                                          // 0x02A4(0x0004)(BlueprintVisible, BlueprintReadOnly, Net, ZeroConstructor, IsPlainOldData, RepNotify, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         CompressedPing;                                    // 0x02A8(0x0001)(BlueprintVisible, BlueprintReadOnly, Net, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_2A9[0x1];                                      // 0x02A9(0x0001)(Fixing Size After Last Property [ Dumper-7 ])
	uint8                                         bShouldUpdateReplicatedPing : 1;                   // 0x02AA(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, DisableEditOnInstance, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate))
	uint8                                         bIsSpectator : 1;                                  // 0x02AA(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (BlueprintVisible, BlueprintReadOnly, Net, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bOnlySpectator : 1;                                // 0x02AA(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Net, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bIsABot : 1;                                       // 0x02AA(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (BlueprintVisible, BlueprintReadOnly, Net, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         BitPad_2AA_4 : 1;                                  // 0x02AA(0x0001)(Fixing Bit-Field Size Between Bits [ Dumper-7 ])
	uint8                                         bIsInactive : 1;                                   // 0x02AA(0x0001)(BitIndex: 0x05, PropSize: 0x0001 (Net, RepNotify, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bFromPreviousLevel : 1;                            // 0x02AA(0x0001)(BitIndex: 0x06, PropSize: 0x0001 (Net, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_2AB[0x1];                                      // 0x02AB(0x0001)(Fixing Size After Last Property [ Dumper-7 ])
	int32                                         startTime;                                         // 0x02AC(0x0004)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TSubclassOf<class ULocalMessage>              EngineMessageClass;                                // 0x02B0(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_2B8[0x8];                                      // 0x02B8(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	class FString                                 SavedNetworkAddress;                               // 0x02C0(0x0010)(ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FUniqueNetIdRepl                       UniqueID;                                          // 0x02D0(0x0030)(Net, RepNotify, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_300[0x8];                                      // 0x0300(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	TMulticastInlineDelegate<void(class APlayerState* Player, class APawn* NewPawn, class APawn* OldPawn)> OnPawnSet; // 0x0308(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	class APawn*                                  PawnPrivate;                                       // 0x0318(0x0008)(BlueprintVisible, BlueprintReadOnly, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_320[0x18];                                     // 0x0320(0x0018)(Fixing Size After Last Property [ Dumper-7 ])
	class FString                                 PlayerNamePrivate;                                 // 0x0338(0x0010)(Net, ZeroConstructor, RepNotify, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_348[0x10];                                     // 0x0348(0x0010)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void OnPawnPrivateDestroyed(class AActor* InActor);
	void OnRep_bIsInactive();
	void OnRep_PlayerId();
	void OnRep_PlayerName();
	void OnRep_Score();
	void OnRep_UniqueId();
	void ReceiveCopyProperties(class APlayerState* NewPlayerState);
	void ReceiveOverrideWith(class APlayerState* OldPlayerState);

	struct FUniqueNetIdRepl BP_GetUniqueId() const;
	uint8 GetCompressedPing() const;
	class APawn* GetPawn() const;
	float GetPingInMilliseconds() const;
	class APlayerController* GetPlayerController() const;
	int32 GetPlayerId() const;
	class FString GetPlayerName() const;
	float GetScore() const;
	bool IsABot() const;
	bool IsOnlyASpectator() const;
	bool IsSpectator() const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"PlayerState">();
	}
	static class APlayerState* GetDefaultObj()
	{
		return GetDefaultObjImpl<APlayerState>();
	}
};
static_assert(alignof(APlayerState) == 0x000008, "Wrong alignment on APlayerState");
static_assert(sizeof(APlayerState) == 0x000358, "Wrong size on APlayerState");
static_assert(offsetof(APlayerState, Score) == 0x0002A0, "Member 'APlayerState::Score' has a wrong offset!");
static_assert(offsetof(APlayerState, PlayerId) == 0x0002A4, "Member 'APlayerState::PlayerId' has a wrong offset!");
static_assert(offsetof(APlayerState, CompressedPing) == 0x0002A8, "Member 'APlayerState::CompressedPing' has a wrong offset!");
static_assert(offsetof(APlayerState, startTime) == 0x0002AC, "Member 'APlayerState::startTime' has a wrong offset!");
static_assert(offsetof(APlayerState, EngineMessageClass) == 0x0002B0, "Member 'APlayerState::EngineMessageClass' has a wrong offset!");
static_assert(offsetof(APlayerState, SavedNetworkAddress) == 0x0002C0, "Member 'APlayerState::SavedNetworkAddress' has a wrong offset!");
static_assert(offsetof(APlayerState, UniqueID) == 0x0002D0, "Member 'APlayerState::UniqueID' has a wrong offset!");
static_assert(offsetof(APlayerState, OnPawnSet) == 0x000308, "Member 'APlayerState::OnPawnSet' has a wrong offset!");
static_assert(offsetof(APlayerState, PawnPrivate) == 0x000318, "Member 'APlayerState::PawnPrivate' has a wrong offset!");
static_assert(offsetof(APlayerState, PlayerNamePrivate) == 0x000338, "Member 'APlayerState::PlayerNamePrivate' has a wrong offset!");

// Class Engine.MaterialExpressionTextureSampleParameterVolume
// 0x0000 (0x0240 - 0x0240)
class UMaterialExpressionTextureSampleParameterVolume final : public UMaterialExpressionTextureSampleParameter
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionTextureSampleParameterVolume">();
	}
	static class UMaterialExpressionTextureSampleParameterVolume* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionTextureSampleParameterVolume>();
	}
};
static_assert(alignof(UMaterialExpressionTextureSampleParameterVolume) == 0x000008, "Wrong alignment on UMaterialExpressionTextureSampleParameterVolume");
static_assert(sizeof(UMaterialExpressionTextureSampleParameterVolume) == 0x000240, "Wrong size on UMaterialExpressionTextureSampleParameterVolume");

// Class Engine.MaterialExpressionThinTranslucentMaterialOutput
// 0x0028 (0x00D8 - 0x00B0)
class UMaterialExpressionThinTranslucentMaterialOutput final : public UMaterialExpressionCustomOutput
{
public:
	struct FExpressionInput                       TransmittanceColor;                                // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionThinTranslucentMaterialOutput">();
	}
	static class UMaterialExpressionThinTranslucentMaterialOutput* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionThinTranslucentMaterialOutput>();
	}
};
static_assert(alignof(UMaterialExpressionThinTranslucentMaterialOutput) == 0x000008, "Wrong alignment on UMaterialExpressionThinTranslucentMaterialOutput");
static_assert(sizeof(UMaterialExpressionThinTranslucentMaterialOutput) == 0x0000D8, "Wrong size on UMaterialExpressionThinTranslucentMaterialOutput");
static_assert(offsetof(UMaterialExpressionThinTranslucentMaterialOutput, TransmittanceColor) == 0x0000B0, "Member 'UMaterialExpressionThinTranslucentMaterialOutput::TransmittanceColor' has a wrong offset!");

// Class Engine.MaterialExpressionTransform
// 0x0030 (0x00E0 - 0x00B0)
class UMaterialExpressionTransform final : public UMaterialExpression
{
public:
	struct FExpressionInput                       Input;                                             // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	EMaterialVectorCoordTransformSource           TransformSourceType;                               // 0x00D8(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EMaterialVectorCoordTransform                 TransformType;                                     // 0x00D9(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_DA[0x6];                                       // 0x00DA(0x0006)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionTransform">();
	}
	static class UMaterialExpressionTransform* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionTransform>();
	}
};
static_assert(alignof(UMaterialExpressionTransform) == 0x000008, "Wrong alignment on UMaterialExpressionTransform");
static_assert(sizeof(UMaterialExpressionTransform) == 0x0000E0, "Wrong size on UMaterialExpressionTransform");
static_assert(offsetof(UMaterialExpressionTransform, Input) == 0x0000B0, "Member 'UMaterialExpressionTransform::Input' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionTransform, TransformSourceType) == 0x0000D8, "Member 'UMaterialExpressionTransform::TransformSourceType' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionTransform, TransformType) == 0x0000D9, "Member 'UMaterialExpressionTransform::TransformType' has a wrong offset!");

// Class Engine.HealthSnapshotBlueprintLibrary
// 0x0000 (0x0028 - 0x0028)
class UHealthSnapshotBlueprintLibrary final : public UBlueprintFunctionLibrary
{
public:
	static void LogPerformanceSnapshot(const class FString& SnapshotTitle, bool bResetStats);
	static void StartPerformanceSnapshots();
	static void StopPerformanceSnapshots();

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"HealthSnapshotBlueprintLibrary">();
	}
	static class UHealthSnapshotBlueprintLibrary* GetDefaultObj()
	{
		return GetDefaultObjImpl<UHealthSnapshotBlueprintLibrary>();
	}
};
static_assert(alignof(UHealthSnapshotBlueprintLibrary) == 0x000008, "Wrong alignment on UHealthSnapshotBlueprintLibrary");
static_assert(sizeof(UHealthSnapshotBlueprintLibrary) == 0x000028, "Wrong size on UHealthSnapshotBlueprintLibrary");

// Class Engine.MaterialExpressionTransformPosition
// 0x0030 (0x00E0 - 0x00B0)
class UMaterialExpressionTransformPosition final : public UMaterialExpression
{
public:
	struct FExpressionInput                       Input;                                             // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	EMaterialPositionTransformSource              TransformSourceType;                               // 0x00D8(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EMaterialPositionTransformSource              TransformType;                                     // 0x00D9(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_DA[0x6];                                       // 0x00DA(0x0006)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionTransformPosition">();
	}
	static class UMaterialExpressionTransformPosition* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionTransformPosition>();
	}
};
static_assert(alignof(UMaterialExpressionTransformPosition) == 0x000008, "Wrong alignment on UMaterialExpressionTransformPosition");
static_assert(sizeof(UMaterialExpressionTransformPosition) == 0x0000E0, "Wrong size on UMaterialExpressionTransformPosition");
static_assert(offsetof(UMaterialExpressionTransformPosition, Input) == 0x0000B0, "Member 'UMaterialExpressionTransformPosition::Input' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionTransformPosition, TransformSourceType) == 0x0000D8, "Member 'UMaterialExpressionTransformPosition::TransformSourceType' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionTransformPosition, TransformType) == 0x0000D9, "Member 'UMaterialExpressionTransformPosition::TransformType' has a wrong offset!");

// Class Engine.MaterialExpressionTruncate
// 0x0028 (0x00D8 - 0x00B0)
class UMaterialExpressionTruncate final : public UMaterialExpression
{
public:
	struct FExpressionInput                       Input;                                             // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionTruncate">();
	}
	static class UMaterialExpressionTruncate* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionTruncate>();
	}
};
static_assert(alignof(UMaterialExpressionTruncate) == 0x000008, "Wrong alignment on UMaterialExpressionTruncate");
static_assert(sizeof(UMaterialExpressionTruncate) == 0x0000D8, "Wrong size on UMaterialExpressionTruncate");
static_assert(offsetof(UMaterialExpressionTruncate, Input) == 0x0000B0, "Member 'UMaterialExpressionTruncate::Input' has a wrong offset!");

// Class Engine.MaterialExpressionTwoSidedSign
// 0x0000 (0x00B0 - 0x00B0)
class UMaterialExpressionTwoSidedSign final : public UMaterialExpression
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionTwoSidedSign">();
	}
	static class UMaterialExpressionTwoSidedSign* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionTwoSidedSign>();
	}
};
static_assert(alignof(UMaterialExpressionTwoSidedSign) == 0x000008, "Wrong alignment on UMaterialExpressionTwoSidedSign");
static_assert(sizeof(UMaterialExpressionTwoSidedSign) == 0x0000B0, "Wrong size on UMaterialExpressionTwoSidedSign");

// Class Engine.MaterialInstanceActor
// 0x0010 (0x02B0 - 0x02A0)
class AMaterialInstanceActor final : public AActor
{
public:
	TArray<class AActor*>                         TargetActors;                                      // 0x02A0(0x0010)(Edit, BlueprintVisible, ZeroConstructor, UObjectWrapper, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialInstanceActor">();
	}
	static class AMaterialInstanceActor* GetDefaultObj()
	{
		return GetDefaultObjImpl<AMaterialInstanceActor>();
	}
};
static_assert(alignof(AMaterialInstanceActor) == 0x000008, "Wrong alignment on AMaterialInstanceActor");
static_assert(sizeof(AMaterialInstanceActor) == 0x0002B0, "Wrong size on AMaterialInstanceActor");
static_assert(offsetof(AMaterialInstanceActor, TargetActors) == 0x0002A0, "Member 'AMaterialInstanceActor::TargetActors' has a wrong offset!");

// Class Engine.MaterialExpressionVectorNoise
// 0x0038 (0x00E8 - 0x00B0)
class UMaterialExpressionVectorNoise final : public UMaterialExpression
{
public:
	struct FExpressionInput                       position;                                          // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	EVectorNoiseFunction                          NoiseFunction;                                     // 0x00D8(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_D9[0x3];                                       // 0x00D9(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	int32                                         Quality;                                           // 0x00DC(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bTiling : 1;                                       // 0x00E0(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_E1[0x3];                                       // 0x00E1(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	uint32                                        TileSize;                                          // 0x00E4(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionVectorNoise">();
	}
	static class UMaterialExpressionVectorNoise* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionVectorNoise>();
	}
};
static_assert(alignof(UMaterialExpressionVectorNoise) == 0x000008, "Wrong alignment on UMaterialExpressionVectorNoise");
static_assert(sizeof(UMaterialExpressionVectorNoise) == 0x0000E8, "Wrong size on UMaterialExpressionVectorNoise");
static_assert(offsetof(UMaterialExpressionVectorNoise, position) == 0x0000B0, "Member 'UMaterialExpressionVectorNoise::position' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionVectorNoise, NoiseFunction) == 0x0000D8, "Member 'UMaterialExpressionVectorNoise::NoiseFunction' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionVectorNoise, Quality) == 0x0000DC, "Member 'UMaterialExpressionVectorNoise::Quality' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionVectorNoise, TileSize) == 0x0000E4, "Member 'UMaterialExpressionVectorNoise::TileSize' has a wrong offset!");

// Class Engine.MaterialExpressionVertexColor
// 0x0000 (0x00B0 - 0x00B0)
class UMaterialExpressionVertexColor final : public UMaterialExpression
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionVertexColor">();
	}
	static class UMaterialExpressionVertexColor* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionVertexColor>();
	}
};
static_assert(alignof(UMaterialExpressionVertexColor) == 0x000008, "Wrong alignment on UMaterialExpressionVertexColor");
static_assert(sizeof(UMaterialExpressionVertexColor) == 0x0000B0, "Wrong size on UMaterialExpressionVertexColor");

// Class Engine.MaterialExpressionVertexInterpolator
// 0x0038 (0x00E8 - 0x00B0)
class UMaterialExpressionVertexInterpolator final : public UMaterialExpressionCustomOutput
{
public:
	struct FExpressionInput                       Input;                                             // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	uint8                                         Pad_D8[0x10];                                      // 0x00D8(0x0010)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionVertexInterpolator">();
	}
	static class UMaterialExpressionVertexInterpolator* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionVertexInterpolator>();
	}
};
static_assert(alignof(UMaterialExpressionVertexInterpolator) == 0x000008, "Wrong alignment on UMaterialExpressionVertexInterpolator");
static_assert(sizeof(UMaterialExpressionVertexInterpolator) == 0x0000E8, "Wrong size on UMaterialExpressionVertexInterpolator");
static_assert(offsetof(UMaterialExpressionVertexInterpolator, Input) == 0x0000B0, "Member 'UMaterialExpressionVertexInterpolator::Input' has a wrong offset!");

// Class Engine.MaterialExpressionVertexNormalWS
// 0x0000 (0x00B0 - 0x00B0)
class UMaterialExpressionVertexNormalWS final : public UMaterialExpression
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionVertexNormalWS">();
	}
	static class UMaterialExpressionVertexNormalWS* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionVertexNormalWS>();
	}
};
static_assert(alignof(UMaterialExpressionVertexNormalWS) == 0x000008, "Wrong alignment on UMaterialExpressionVertexNormalWS");
static_assert(sizeof(UMaterialExpressionVertexNormalWS) == 0x0000B0, "Wrong size on UMaterialExpressionVertexNormalWS");

// Class Engine.MaterialInstanceDynamic
// 0x0050 (0x0298 - 0x0248)
class UMaterialInstanceDynamic final : public UMaterialInstance
{
public:
	uint8                                         Pad_248[0x50];                                     // 0x0248(0x0050)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void CopyInterpParameters(class UMaterialInstance* Source);
	void CopyParameterOverrides(class UMaterialInstance* MaterialInstance);
	bool InitializeScalarParameterAndGetIndex(const class FName& ParameterName, float Value, int32* OutParameterIndex);
	void K2_CopyMaterialInstanceParameters(class UMaterialInterface* Source, bool bQuickParametersOnly);
	float K2_GetScalarParameterValue(class FName ParameterName);
	float K2_GetScalarParameterValueByInfo(const struct FMaterialParameterInfo& ParameterInfo);
	class UTexture* K2_GetTextureParameterValue(class FName ParameterName);
	class UTexture* K2_GetTextureParameterValueByInfo(const struct FMaterialParameterInfo& ParameterInfo);
	struct FLinearColor K2_GetVectorParameterValue(class FName ParameterName);
	struct FLinearColor K2_GetVectorParameterValueByInfo(const struct FMaterialParameterInfo& ParameterInfo);
	void K2_InterpolateMaterialInstanceParams(class UMaterialInstance* SourceA, class UMaterialInstance* SourceB, float Alpha);
	void SetDoubleVectorParameterValue(class FName ParameterName, const struct FVector4& Value);
	void SetRuntimeVirtualTextureParameterValue(class FName ParameterName, class URuntimeVirtualTexture* Value);
	void SetRuntimeVirtualTextureParameterValueByInfo(const struct FMaterialParameterInfo& ParameterInfo, class URuntimeVirtualTexture* Value);
	bool SetScalarParameterByIndex(int32 ParameterIndex, float Value);
	void SetScalarParameterValue(class FName ParameterName, float Value);
	void SetScalarParameterValueByInfo(const struct FMaterialParameterInfo& ParameterInfo, float Value);
	void SetSparseVolumeTextureParameterValue(class FName ParameterName, class USparseVolumeTexture* Value);
	void SetTextureParameterValue(class FName ParameterName, class UTexture* Value);
	void SetTextureParameterValueByInfo(const struct FMaterialParameterInfo& ParameterInfo, class UTexture* Value);
	void SetVectorParameterValue(class FName ParameterName, const struct FLinearColor& Value);
	void SetVectorParameterValueByInfo(const struct FMaterialParameterInfo& ParameterInfo, const struct FLinearColor& Value);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialInstanceDynamic">();
	}
	static class UMaterialInstanceDynamic* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialInstanceDynamic>();
	}
};
static_assert(alignof(UMaterialInstanceDynamic) == 0x000008, "Wrong alignment on UMaterialInstanceDynamic");
static_assert(sizeof(UMaterialInstanceDynamic) == 0x000298, "Wrong size on UMaterialInstanceDynamic");

// Class Engine.MaterialExpressionVertexTangentWS
// 0x0000 (0x00B0 - 0x00B0)
class UMaterialExpressionVertexTangentWS final : public UMaterialExpression
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionVertexTangentWS">();
	}
	static class UMaterialExpressionVertexTangentWS* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionVertexTangentWS>();
	}
};
static_assert(alignof(UMaterialExpressionVertexTangentWS) == 0x000008, "Wrong alignment on UMaterialExpressionVertexTangentWS");
static_assert(sizeof(UMaterialExpressionVertexTangentWS) == 0x0000B0, "Wrong size on UMaterialExpressionVertexTangentWS");

// Class Engine.MaterialExpressionViewProperty
// 0x0008 (0x00B8 - 0x00B0)
class UMaterialExpressionViewProperty final : public UMaterialExpression
{
public:
	EMaterialExposedViewProperty                  Property;                                          // 0x00B0(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_B1[0x7];                                       // 0x00B1(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionViewProperty">();
	}
	static class UMaterialExpressionViewProperty* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionViewProperty>();
	}
};
static_assert(alignof(UMaterialExpressionViewProperty) == 0x000008, "Wrong alignment on UMaterialExpressionViewProperty");
static_assert(sizeof(UMaterialExpressionViewProperty) == 0x0000B8, "Wrong size on UMaterialExpressionViewProperty");
static_assert(offsetof(UMaterialExpressionViewProperty, Property) == 0x0000B0, "Member 'UMaterialExpressionViewProperty::Property' has a wrong offset!");

// Class Engine.MaterialExpressionViewSize
// 0x0000 (0x00B0 - 0x00B0)
class UMaterialExpressionViewSize final : public UMaterialExpression
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionViewSize">();
	}
	static class UMaterialExpressionViewSize* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionViewSize>();
	}
};
static_assert(alignof(UMaterialExpressionViewSize) == 0x000008, "Wrong alignment on UMaterialExpressionViewSize");
static_assert(sizeof(UMaterialExpressionViewSize) == 0x0000B0, "Wrong size on UMaterialExpressionViewSize");

// Class Engine.MaterialExpressionVirtualTextureFeatureSwitch
// 0x0050 (0x0100 - 0x00B0)
class UMaterialExpressionVirtualTextureFeatureSwitch final : public UMaterialExpression
{
public:
	struct FExpressionInput                       No;                                                // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       Yes;                                               // 0x00D8(0x0028)(NoDestructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionVirtualTextureFeatureSwitch">();
	}
	static class UMaterialExpressionVirtualTextureFeatureSwitch* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionVirtualTextureFeatureSwitch>();
	}
};
static_assert(alignof(UMaterialExpressionVirtualTextureFeatureSwitch) == 0x000008, "Wrong alignment on UMaterialExpressionVirtualTextureFeatureSwitch");
static_assert(sizeof(UMaterialExpressionVirtualTextureFeatureSwitch) == 0x000100, "Wrong size on UMaterialExpressionVirtualTextureFeatureSwitch");
static_assert(offsetof(UMaterialExpressionVirtualTextureFeatureSwitch, No) == 0x0000B0, "Member 'UMaterialExpressionVirtualTextureFeatureSwitch::No' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionVirtualTextureFeatureSwitch, Yes) == 0x0000D8, "Member 'UMaterialExpressionVirtualTextureFeatureSwitch::Yes' has a wrong offset!");

// Class Engine.MaterialExpressionVolumetricCloudEmptySpaceSkippingInput
// 0x0000 (0x00B0 - 0x00B0)
class UMaterialExpressionVolumetricCloudEmptySpaceSkippingInput final : public UMaterialExpression
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionVolumetricCloudEmptySpaceSkippingInput">();
	}
	static class UMaterialExpressionVolumetricCloudEmptySpaceSkippingInput* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionVolumetricCloudEmptySpaceSkippingInput>();
	}
};
static_assert(alignof(UMaterialExpressionVolumetricCloudEmptySpaceSkippingInput) == 0x000008, "Wrong alignment on UMaterialExpressionVolumetricCloudEmptySpaceSkippingInput");
static_assert(sizeof(UMaterialExpressionVolumetricCloudEmptySpaceSkippingInput) == 0x0000B0, "Wrong size on UMaterialExpressionVolumetricCloudEmptySpaceSkippingInput");

// Class Engine.MaterialExpressionVolumetricAdvancedMaterialOutput
// 0x0140 (0x01F0 - 0x00B0)
class UMaterialExpressionVolumetricAdvancedMaterialOutput final : public UMaterialExpressionCustomOutput
{
public:
	struct FExpressionInput                       PhaseG;                                            // 0x00B0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       PhaseG2;                                           // 0x00D8(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       PhaseBlend;                                        // 0x0100(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       MultiScatteringContribution;                       // 0x0128(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       MultiScatteringOcclusion;                          // 0x0150(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       MultiScatteringEccentricity;                       // 0x0178(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       ConservativeDensity;                               // 0x01A0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)
	float                                         ConstPhaseG;                                       // 0x01C8(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         ConstPhaseG2;                                      // 0x01CC(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         ConstPhaseBlend;                                   // 0x01D0(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          PerSamplePhaseEvaluation;                          // 0x01D4(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1D5[0x3];                                      // 0x01D5(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	uint32                                        MultiScatteringApproximationOctaveCount;           // 0x01D8(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         ConstMultiScatteringContribution;                  // 0x01DC(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         ConstMultiScatteringOcclusion;                     // 0x01E0(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         ConstMultiScatteringEccentricity;                  // 0x01E4(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bGroundContribution;                               // 0x01E8(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bGrayScaleMaterial;                                // 0x01E9(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bRayMarchVolumeShadow;                             // 0x01EA(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bClampMultiScatteringContribution;                 // 0x01EB(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1EC[0x4];                                      // 0x01EC(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionVolumetricAdvancedMaterialOutput">();
	}
	static class UMaterialExpressionVolumetricAdvancedMaterialOutput* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionVolumetricAdvancedMaterialOutput>();
	}
};
static_assert(alignof(UMaterialExpressionVolumetricAdvancedMaterialOutput) == 0x000008, "Wrong alignment on UMaterialExpressionVolumetricAdvancedMaterialOutput");
static_assert(sizeof(UMaterialExpressionVolumetricAdvancedMaterialOutput) == 0x0001F0, "Wrong size on UMaterialExpressionVolumetricAdvancedMaterialOutput");
static_assert(offsetof(UMaterialExpressionVolumetricAdvancedMaterialOutput, PhaseG) == 0x0000B0, "Member 'UMaterialExpressionVolumetricAdvancedMaterialOutput::PhaseG' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionVolumetricAdvancedMaterialOutput, PhaseG2) == 0x0000D8, "Member 'UMaterialExpressionVolumetricAdvancedMaterialOutput::PhaseG2' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionVolumetricAdvancedMaterialOutput, PhaseBlend) == 0x000100, "Member 'UMaterialExpressionVolumetricAdvancedMaterialOutput::PhaseBlend' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionVolumetricAdvancedMaterialOutput, MultiScatteringContribution) == 0x000128, "Member 'UMaterialExpressionVolumetricAdvancedMaterialOutput::MultiScatteringContribution' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionVolumetricAdvancedMaterialOutput, MultiScatteringOcclusion) == 0x000150, "Member 'UMaterialExpressionVolumetricAdvancedMaterialOutput::MultiScatteringOcclusion' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionVolumetricAdvancedMaterialOutput, MultiScatteringEccentricity) == 0x000178, "Member 'UMaterialExpressionVolumetricAdvancedMaterialOutput::MultiScatteringEccentricity' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionVolumetricAdvancedMaterialOutput, ConservativeDensity) == 0x0001A0, "Member 'UMaterialExpressionVolumetricAdvancedMaterialOutput::ConservativeDensity' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionVolumetricAdvancedMaterialOutput, ConstPhaseG) == 0x0001C8, "Member 'UMaterialExpressionVolumetricAdvancedMaterialOutput::ConstPhaseG' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionVolumetricAdvancedMaterialOutput, ConstPhaseG2) == 0x0001CC, "Member 'UMaterialExpressionVolumetricAdvancedMaterialOutput::ConstPhaseG2' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionVolumetricAdvancedMaterialOutput, ConstPhaseBlend) == 0x0001D0, "Member 'UMaterialExpressionVolumetricAdvancedMaterialOutput::ConstPhaseBlend' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionVolumetricAdvancedMaterialOutput, PerSamplePhaseEvaluation) == 0x0001D4, "Member 'UMaterialExpressionVolumetricAdvancedMaterialOutput::PerSamplePhaseEvaluation' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionVolumetricAdvancedMaterialOutput, MultiScatteringApproximationOctaveCount) == 0x0001D8, "Member 'UMaterialExpressionVolumetricAdvancedMaterialOutput::MultiScatteringApproximationOctaveCount' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionVolumetricAdvancedMaterialOutput, ConstMultiScatteringContribution) == 0x0001DC, "Member 'UMaterialExpressionVolumetricAdvancedMaterialOutput::ConstMultiScatteringContribution' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionVolumetricAdvancedMaterialOutput, ConstMultiScatteringOcclusion) == 0x0001E0, "Member 'UMaterialExpressionVolumetricAdvancedMaterialOutput::ConstMultiScatteringOcclusion' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionVolumetricAdvancedMaterialOutput, ConstMultiScatteringEccentricity) == 0x0001E4, "Member 'UMaterialExpressionVolumetricAdvancedMaterialOutput::ConstMultiScatteringEccentricity' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionVolumetricAdvancedMaterialOutput, bGroundContribution) == 0x0001E8, "Member 'UMaterialExpressionVolumetricAdvancedMaterialOutput::bGroundContribution' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionVolumetricAdvancedMaterialOutput, bGrayScaleMaterial) == 0x0001E9, "Member 'UMaterialExpressionVolumetricAdvancedMaterialOutput::bGrayScaleMaterial' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionVolumetricAdvancedMaterialOutput, bRayMarchVolumeShadow) == 0x0001EA, "Member 'UMaterialExpressionVolumetricAdvancedMaterialOutput::bRayMarchVolumeShadow' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionVolumetricAdvancedMaterialOutput, bClampMultiScatteringContribution) == 0x0001EB, "Member 'UMaterialExpressionVolumetricAdvancedMaterialOutput::bClampMultiScatteringContribution' has a wrong offset!");

// Class Engine.NetworkSettings
// 0x0018 (0x0050 - 0x0038)
class UNetworkSettings final : public UDeveloperSettings
{
public:
	uint8                                         bVerifyPeer : 1;                                   // 0x0038(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bEnableMultiplayerWorldOriginRebasing : 1;         // 0x0038(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_39[0x7];                                       // 0x0039(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<struct FNetworkEmulationProfileDescription> NetworkEmulationProfiles;                     // 0x0040(0x0010)(ZeroConstructor, Config, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"NetworkSettings">();
	}
	static class UNetworkSettings* GetDefaultObj()
	{
		return GetDefaultObjImpl<UNetworkSettings>();
	}
};
static_assert(alignof(UNetworkSettings) == 0x000008, "Wrong alignment on UNetworkSettings");
static_assert(sizeof(UNetworkSettings) == 0x000050, "Wrong size on UNetworkSettings");
static_assert(offsetof(UNetworkSettings, NetworkEmulationProfiles) == 0x000040, "Member 'UNetworkSettings::NetworkEmulationProfiles' has a wrong offset!");

// Class Engine.MaterialExpressionWhileLoop
// 0x0038 (0x00E8 - 0x00B0)
class UMaterialExpressionWhileLoop final : public UMaterialExpression
{
public:
	struct FExpressionExecOutput                  LoopBody;                                          // 0x00B0(0x0008)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionExecOutput                  Completed;                                         // 0x00B8(0x0008)(NoDestructor, NativeAccessSpecifierPublic)
	struct FExpressionInput                       Condition;                                         // 0x00C0(0x0028)(NoDestructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionWhileLoop">();
	}
	static class UMaterialExpressionWhileLoop* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionWhileLoop>();
	}
};
static_assert(alignof(UMaterialExpressionWhileLoop) == 0x000008, "Wrong alignment on UMaterialExpressionWhileLoop");
static_assert(sizeof(UMaterialExpressionWhileLoop) == 0x0000E8, "Wrong size on UMaterialExpressionWhileLoop");
static_assert(offsetof(UMaterialExpressionWhileLoop, LoopBody) == 0x0000B0, "Member 'UMaterialExpressionWhileLoop::LoopBody' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionWhileLoop, Completed) == 0x0000B8, "Member 'UMaterialExpressionWhileLoop::Completed' has a wrong offset!");
static_assert(offsetof(UMaterialExpressionWhileLoop, Condition) == 0x0000C0, "Member 'UMaterialExpressionWhileLoop::Condition' has a wrong offset!");

// Class Engine.MaterialExpressionWorldPosition
// 0x0008 (0x00B8 - 0x00B0)
class UMaterialExpressionWorldPosition final : public UMaterialExpression
{
public:
	EWorldPositionIncludedOffsets                 WorldPositionShaderOffset;                         // 0x00B0(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_B1[0x7];                                       // 0x00B1(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialExpressionWorldPosition">();
	}
	static class UMaterialExpressionWorldPosition* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialExpressionWorldPosition>();
	}
};
static_assert(alignof(UMaterialExpressionWorldPosition) == 0x000008, "Wrong alignment on UMaterialExpressionWorldPosition");
static_assert(sizeof(UMaterialExpressionWorldPosition) == 0x0000B8, "Wrong size on UMaterialExpressionWorldPosition");
static_assert(offsetof(UMaterialExpressionWorldPosition, WorldPositionShaderOffset) == 0x0000B0, "Member 'UMaterialExpressionWorldPosition::WorldPositionShaderOffset' has a wrong offset!");

// Class Engine.MaterialFunctionInterfaceEditorOnlyData
// 0x0000 (0x0028 - 0x0028)
class UMaterialFunctionInterfaceEditorOnlyData : public UObject
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialFunctionInterfaceEditorOnlyData">();
	}
	static class UMaterialFunctionInterfaceEditorOnlyData* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialFunctionInterfaceEditorOnlyData>();
	}
};
static_assert(alignof(UMaterialFunctionInterfaceEditorOnlyData) == 0x000008, "Wrong alignment on UMaterialFunctionInterfaceEditorOnlyData");
static_assert(sizeof(UMaterialFunctionInterfaceEditorOnlyData) == 0x000028, "Wrong size on UMaterialFunctionInterfaceEditorOnlyData");

// Class Engine.MaterialFunctionEditorOnlyData
// 0x0030 (0x0058 - 0x0028)
class UMaterialFunctionEditorOnlyData final : public UMaterialFunctionInterfaceEditorOnlyData
{
public:
	struct FMaterialExpressionCollection          ExpressionCollection;                              // 0x0028(0x0030)(NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialFunctionEditorOnlyData">();
	}
	static class UMaterialFunctionEditorOnlyData* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialFunctionEditorOnlyData>();
	}
};
static_assert(alignof(UMaterialFunctionEditorOnlyData) == 0x000008, "Wrong alignment on UMaterialFunctionEditorOnlyData");
static_assert(sizeof(UMaterialFunctionEditorOnlyData) == 0x000058, "Wrong size on UMaterialFunctionEditorOnlyData");
static_assert(offsetof(UMaterialFunctionEditorOnlyData, ExpressionCollection) == 0x000028, "Member 'UMaterialFunctionEditorOnlyData::ExpressionCollection' has a wrong offset!");

// Class Engine.MaterialFunctionMaterialLayer
// 0x0000 (0x0068 - 0x0068)
class UMaterialFunctionMaterialLayer final : public UMaterialFunction
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialFunctionMaterialLayer">();
	}
	static class UMaterialFunctionMaterialLayer* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialFunctionMaterialLayer>();
	}
};
static_assert(alignof(UMaterialFunctionMaterialLayer) == 0x000008, "Wrong alignment on UMaterialFunctionMaterialLayer");
static_assert(sizeof(UMaterialFunctionMaterialLayer) == 0x000068, "Wrong size on UMaterialFunctionMaterialLayer");

// Class Engine.MaterialFunctionMaterialLayerBlend
// 0x0000 (0x0068 - 0x0068)
class UMaterialFunctionMaterialLayerBlend final : public UMaterialFunction
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialFunctionMaterialLayerBlend">();
	}
	static class UMaterialFunctionMaterialLayerBlend* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialFunctionMaterialLayerBlend>();
	}
};
static_assert(alignof(UMaterialFunctionMaterialLayerBlend) == 0x000008, "Wrong alignment on UMaterialFunctionMaterialLayerBlend");
static_assert(sizeof(UMaterialFunctionMaterialLayerBlend) == 0x000068, "Wrong size on UMaterialFunctionMaterialLayerBlend");

// Class Engine.DeformableInterface
// 0x0000 (0x0000 - 0x0000)
class IDeformableInterface final
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"DeformableInterface">();
	}
	static class IDeformableInterface* GetDefaultObj()
	{
		return GetDefaultObjImpl<IDeformableInterface>();
	}

	class UObject* AsUObject()
	{
		return reinterpret_cast<UObject*>(this);
	}
	const class UObject* AsUObject() const
	{
		return reinterpret_cast<const UObject*>(this);
	}
};
static_assert(alignof(IDeformableInterface) == 0x000001, "Wrong alignment on IDeformableInterface");
static_assert(sizeof(IDeformableInterface) == 0x000001, "Wrong size on IDeformableInterface");

// Class Engine.MeshBudgetProjectSettings
// 0x0018 (0x0050 - 0x0038)
class UMeshBudgetProjectSettings final : public UDeveloperSettings
{
public:
	bool                                          bEnableStaticMeshBudget;                           // 0x0038(0x0001)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_39[0x7];                                       // 0x0039(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<struct FStaticMeshBudgetInfo>          StaticMeshBudgetInfos;                             // 0x0040(0x0010)(Edit, ZeroConstructor, Config, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MeshBudgetProjectSettings">();
	}
	static class UMeshBudgetProjectSettings* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMeshBudgetProjectSettings>();
	}
};
static_assert(alignof(UMeshBudgetProjectSettings) == 0x000008, "Wrong alignment on UMeshBudgetProjectSettings");
static_assert(sizeof(UMeshBudgetProjectSettings) == 0x000050, "Wrong size on UMeshBudgetProjectSettings");
static_assert(offsetof(UMeshBudgetProjectSettings, bEnableStaticMeshBudget) == 0x000038, "Member 'UMeshBudgetProjectSettings::bEnableStaticMeshBudget' has a wrong offset!");
static_assert(offsetof(UMeshBudgetProjectSettings, StaticMeshBudgetInfos) == 0x000040, "Member 'UMeshBudgetProjectSettings::StaticMeshBudgetInfos' has a wrong offset!");

// Class Engine.TextureLODSettings
// 0x0010 (0x0038 - 0x0028)
class UTextureLODSettings : public UObject
{
public:
	TArray<struct FTextureLODGroup>               TextureLODGroups;                                  // 0x0028(0x0010)(Edit, ZeroConstructor, Config, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"TextureLODSettings">();
	}
	static class UTextureLODSettings* GetDefaultObj()
	{
		return GetDefaultObjImpl<UTextureLODSettings>();
	}
};
static_assert(alignof(UTextureLODSettings) == 0x000008, "Wrong alignment on UTextureLODSettings");
static_assert(sizeof(UTextureLODSettings) == 0x000038, "Wrong size on UTextureLODSettings");
static_assert(offsetof(UTextureLODSettings, TextureLODGroups) == 0x000028, "Member 'UTextureLODSettings::TextureLODGroups' has a wrong offset!");

// Class Engine.MeshDeformerInstanceSettings
// 0x0000 (0x0028 - 0x0028)
class UMeshDeformerInstanceSettings : public UObject
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MeshDeformerInstanceSettings">();
	}
	static class UMeshDeformerInstanceSettings* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMeshDeformerInstanceSettings>();
	}
};
static_assert(alignof(UMeshDeformerInstanceSettings) == 0x000008, "Wrong alignment on UMeshDeformerInstanceSettings");
static_assert(sizeof(UMeshDeformerInstanceSettings) == 0x000028, "Wrong size on UMeshDeformerInstanceSettings");

// Class Engine.NavAgentInterface
// 0x0000 (0x0000 - 0x0000)
class INavAgentInterface final
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"NavAgentInterface">();
	}
	static class INavAgentInterface* GetDefaultObj()
	{
		return GetDefaultObjImpl<INavAgentInterface>();
	}

	class UObject* AsUObject()
	{
		return reinterpret_cast<UObject*>(this);
	}
	const class UObject* AsUObject() const
	{
		return reinterpret_cast<const UObject*>(this);
	}
};
static_assert(alignof(INavAgentInterface) == 0x000001, "Wrong alignment on INavAgentInterface");
static_assert(sizeof(INavAgentInterface) == 0x000001, "Wrong size on INavAgentInterface");

// Class Engine.NavEdgeProviderInterface
// 0x0000 (0x0000 - 0x0000)
class INavEdgeProviderInterface final
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"NavEdgeProviderInterface">();
	}
	static class INavEdgeProviderInterface* GetDefaultObj()
	{
		return GetDefaultObjImpl<INavEdgeProviderInterface>();
	}

	class UObject* AsUObject()
	{
		return reinterpret_cast<UObject*>(this);
	}
	const class UObject* AsUObject() const
	{
		return reinterpret_cast<const UObject*>(this);
	}
};
static_assert(alignof(INavEdgeProviderInterface) == 0x000001, "Wrong alignment on INavEdgeProviderInterface");
static_assert(sizeof(INavEdgeProviderInterface) == 0x000001, "Wrong size on INavEdgeProviderInterface");

// Class Engine.LocalHeightFogComponent
// 0x0050 (0x02F0 - 0x02A0)
class ULocalHeightFogComponent final : public USceneComponent
{
public:
	ELocalFogMode                                 FogMode;                                           // 0x02A0(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_2A1[0x3];                                      // 0x02A1(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         FogDensity;                                        // 0x02A4(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         FogHeightFalloff;                                  // 0x02A8(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         FogHeightOffset;                                   // 0x02AC(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         FogRadialAttenuation;                              // 0x02B0(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         FogPhaseG;                                         // 0x02B4(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FLinearColor                           FogAlbedo;                                         // 0x02B8(0x0010)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FLinearColor                           FogEmissive;                                       // 0x02C8(0x0010)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         FogSortPriority;                                   // 0x02D8(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_2DC[0x14];                                     // 0x02DC(0x0014)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"LocalHeightFogComponent">();
	}
	static class ULocalHeightFogComponent* GetDefaultObj()
	{
		return GetDefaultObjImpl<ULocalHeightFogComponent>();
	}
};
static_assert(alignof(ULocalHeightFogComponent) == 0x000010, "Wrong alignment on ULocalHeightFogComponent");
static_assert(sizeof(ULocalHeightFogComponent) == 0x0002F0, "Wrong size on ULocalHeightFogComponent");
static_assert(offsetof(ULocalHeightFogComponent, FogMode) == 0x0002A0, "Member 'ULocalHeightFogComponent::FogMode' has a wrong offset!");
static_assert(offsetof(ULocalHeightFogComponent, FogDensity) == 0x0002A4, "Member 'ULocalHeightFogComponent::FogDensity' has a wrong offset!");
static_assert(offsetof(ULocalHeightFogComponent, FogHeightFalloff) == 0x0002A8, "Member 'ULocalHeightFogComponent::FogHeightFalloff' has a wrong offset!");
static_assert(offsetof(ULocalHeightFogComponent, FogHeightOffset) == 0x0002AC, "Member 'ULocalHeightFogComponent::FogHeightOffset' has a wrong offset!");
static_assert(offsetof(ULocalHeightFogComponent, FogRadialAttenuation) == 0x0002B0, "Member 'ULocalHeightFogComponent::FogRadialAttenuation' has a wrong offset!");
static_assert(offsetof(ULocalHeightFogComponent, FogPhaseG) == 0x0002B4, "Member 'ULocalHeightFogComponent::FogPhaseG' has a wrong offset!");
static_assert(offsetof(ULocalHeightFogComponent, FogAlbedo) == 0x0002B8, "Member 'ULocalHeightFogComponent::FogAlbedo' has a wrong offset!");
static_assert(offsetof(ULocalHeightFogComponent, FogEmissive) == 0x0002C8, "Member 'ULocalHeightFogComponent::FogEmissive' has a wrong offset!");
static_assert(offsetof(ULocalHeightFogComponent, FogSortPriority) == 0x0002D8, "Member 'ULocalHeightFogComponent::FogSortPriority' has a wrong offset!");

// Class Engine.NavLinkDefinition
// 0x0028 (0x0050 - 0x0028)
class UNavLinkDefinition : public UObject
{
public:
	TArray<struct FNavigationLink>                Links;                                             // 0x0028(0x0010)(Edit, ZeroConstructor, NativeAccessSpecifierPublic)
	TArray<struct FNavigationSegmentLink>         SegmentLinks;                                      // 0x0038(0x0010)(Edit, ZeroConstructor, NativeAccessSpecifierPublic)
	uint8                                         Pad_48[0x8];                                       // 0x0048(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"NavLinkDefinition">();
	}
	static class UNavLinkDefinition* GetDefaultObj()
	{
		return GetDefaultObjImpl<UNavLinkDefinition>();
	}
};
static_assert(alignof(UNavLinkDefinition) == 0x000008, "Wrong alignment on UNavLinkDefinition");
static_assert(sizeof(UNavLinkDefinition) == 0x000050, "Wrong size on UNavLinkDefinition");
static_assert(offsetof(UNavLinkDefinition, Links) == 0x000028, "Member 'UNavLinkDefinition::Links' has a wrong offset!");
static_assert(offsetof(UNavLinkDefinition, SegmentLinks) == 0x000038, "Member 'UNavLinkDefinition::SegmentLinks' has a wrong offset!");

// Class Engine.ParticleEmitter
// 0x0198 (0x01C0 - 0x0028)
class UParticleEmitter : public UObject
{
public:
	class FName                                   EmitterName;                                       // 0x0028(0x0008)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         SubUVDataOffset;                                   // 0x0030(0x0004)(ZeroConstructor, Transient, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EEmitterRenderMode                            EmitterRenderMode;                                 // 0x0034(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EParticleSignificanceLevel                    SignificanceLevel;                                 // 0x0035(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_36[0x1];                                       // 0x0036(0x0001)(Fixing Size After Last Property [ Dumper-7 ])
	uint8                                         bUseLegacySpawningBehavior : 1;                    // 0x0037(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         BitPad_37_1 : 3;                                   // 0x0037(0x0001)(Fixing Bit-Field Size Between Bits [ Dumper-7 ])
	uint8                                         ConvertedModules : 1;                              // 0x0037(0x0001)(BitIndex: 0x04, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bIsSoloing : 1;                                    // 0x0037(0x0001)(BitIndex: 0x05, PropSize: 0x0001 (Transient, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bCookedOut : 1;                                    // 0x0037(0x0001)(BitIndex: 0x06, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bDisabledLODsKeepEmitterAlive : 1;                 // 0x0037(0x0001)(BitIndex: 0x07, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bDisableWhenInsignficant : 1;                      // 0x0038(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_39[0x7];                                       // 0x0039(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<class UParticleLODLevel*>              LODLevels;                                         // 0x0040(0x0010)(ExportObject, ZeroConstructor, ContainsInstancedReference, UObjectWrapper, NativeAccessSpecifierPublic)
	int32                                         PeakActiveParticles;                               // 0x0050(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         InitialAllocationCount;                            // 0x0054(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         QualityLevelSpawnRateScale;                        // 0x0058(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint32                                        DetailModeBitmask;                                 // 0x005C(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_60[0x160];                                     // 0x0060(0x0160)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ParticleEmitter">();
	}
	static class UParticleEmitter* GetDefaultObj()
	{
		return GetDefaultObjImpl<UParticleEmitter>();
	}
};
static_assert(alignof(UParticleEmitter) == 0x000008, "Wrong alignment on UParticleEmitter");
static_assert(sizeof(UParticleEmitter) == 0x0001C0, "Wrong size on UParticleEmitter");
static_assert(offsetof(UParticleEmitter, EmitterName) == 0x000028, "Member 'UParticleEmitter::EmitterName' has a wrong offset!");
static_assert(offsetof(UParticleEmitter, SubUVDataOffset) == 0x000030, "Member 'UParticleEmitter::SubUVDataOffset' has a wrong offset!");
static_assert(offsetof(UParticleEmitter, EmitterRenderMode) == 0x000034, "Member 'UParticleEmitter::EmitterRenderMode' has a wrong offset!");
static_assert(offsetof(UParticleEmitter, SignificanceLevel) == 0x000035, "Member 'UParticleEmitter::SignificanceLevel' has a wrong offset!");
static_assert(offsetof(UParticleEmitter, LODLevels) == 0x000040, "Member 'UParticleEmitter::LODLevels' has a wrong offset!");
static_assert(offsetof(UParticleEmitter, PeakActiveParticles) == 0x000050, "Member 'UParticleEmitter::PeakActiveParticles' has a wrong offset!");
static_assert(offsetof(UParticleEmitter, InitialAllocationCount) == 0x000054, "Member 'UParticleEmitter::InitialAllocationCount' has a wrong offset!");
static_assert(offsetof(UParticleEmitter, QualityLevelSpawnRateScale) == 0x000058, "Member 'UParticleEmitter::QualityLevelSpawnRateScale' has a wrong offset!");
static_assert(offsetof(UParticleEmitter, DetailModeBitmask) == 0x00005C, "Member 'UParticleEmitter::DetailModeBitmask' has a wrong offset!");

// Class Engine.PoseableMeshComponent
// 0x0160 (0x0A50 - 0x08F0)
class UPoseableMeshComponent final : public USkinnedMeshComponent
{
public:
	uint8                                         Pad_8F0[0x160];                                    // 0x08F0(0x0160)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void CopyPoseFromSkeletalComponent(class USkeletalMeshComponent* InComponentToCopy);
	struct FVector GetBoneLocationByName(class FName BoneName, EBoneSpaces BoneSpace);
	struct FRotator GetBoneRotationByName(class FName BoneName, EBoneSpaces BoneSpace);
	struct FVector GetBoneScaleByName(class FName BoneName, EBoneSpaces BoneSpace);
	struct FTransform GetBoneTransformByName(class FName BoneName, EBoneSpaces BoneSpace);
	void ResetBoneTransformByName(class FName BoneName);
	void SetBoneLocationByName(class FName BoneName, const struct FVector& InLocation, EBoneSpaces BoneSpace);
	void SetBoneRotationByName(class FName BoneName, const struct FRotator& InRotation, EBoneSpaces BoneSpace);
	void SetBoneScaleByName(class FName BoneName, const struct FVector& InScale3D, EBoneSpaces BoneSpace);
	void SetBoneTransformByName(class FName BoneName, const struct FTransform& InTransform, EBoneSpaces BoneSpace);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"PoseableMeshComponent">();
	}
	static class UPoseableMeshComponent* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPoseableMeshComponent>();
	}
};
static_assert(alignof(UPoseableMeshComponent) == 0x000010, "Wrong alignment on UPoseableMeshComponent");
static_assert(sizeof(UPoseableMeshComponent) == 0x000A50, "Wrong size on UPoseableMeshComponent");

// Class Engine.ParticleModuleAccelerationDrag
// 0x0038 (0x0070 - 0x0038)
class UParticleModuleAccelerationDrag final : public UParticleModuleAccelerationBase
{
public:
	class UDistributionFloat*                     DragCoefficient;                                   // 0x0038(0x0008)(ExportObject, ZeroConstructor, InstancedReference, Deprecated, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FRawDistributionFloat                  DragCoefficientRaw;                                // 0x0040(0x0030)(Edit, ContainsInstancedReference, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ParticleModuleAccelerationDrag">();
	}
	static class UParticleModuleAccelerationDrag* GetDefaultObj()
	{
		return GetDefaultObjImpl<UParticleModuleAccelerationDrag>();
	}
};
static_assert(alignof(UParticleModuleAccelerationDrag) == 0x000008, "Wrong alignment on UParticleModuleAccelerationDrag");
static_assert(sizeof(UParticleModuleAccelerationDrag) == 0x000070, "Wrong size on UParticleModuleAccelerationDrag");
static_assert(offsetof(UParticleModuleAccelerationDrag, DragCoefficient) == 0x000038, "Member 'UParticleModuleAccelerationDrag::DragCoefficient' has a wrong offset!");
static_assert(offsetof(UParticleModuleAccelerationDrag, DragCoefficientRaw) == 0x000040, "Member 'UParticleModuleAccelerationDrag::DragCoefficientRaw' has a wrong offset!");

// Class Engine.ParticleModuleBeamTarget
// 0x0120 (0x0150 - 0x0030)
class UParticleModuleBeamTarget final : public UParticleModuleBeamBase
{
public:
	EBeam2SourceTargetMethod                      TargetMethod;                                      // 0x0030(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_31[0x3];                                       // 0x0031(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	class FName                                   TargetName;                                        // 0x0034(0x0008)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_3C[0x4];                                       // 0x003C(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	struct FRawDistributionVector                 Target;                                            // 0x0040(0x0060)(Edit, ContainsInstancedReference, NativeAccessSpecifierPublic)
	uint8                                         bTargetAbsolute : 1;                               // 0x00A0(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bLockTarget : 1;                                   // 0x00A0(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_A1[0x3];                                       // 0x00A1(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	EBeam2SourceTargetTangentMethod               TargetTangentMethod;                               // 0x00A4(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_A5[0x3];                                       // 0x00A5(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	struct FRawDistributionVector                 TargetTangent;                                     // 0x00A8(0x0060)(Edit, ContainsInstancedReference, NativeAccessSpecifierPublic)
	uint8                                         bLockTargetTangent : 1;                            // 0x0108(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_109[0x7];                                      // 0x0109(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	struct FRawDistributionFloat                  TargetStrength;                                    // 0x0110(0x0030)(Edit, ContainsInstancedReference, NativeAccessSpecifierPublic)
	uint8                                         bLockTargetStength : 1;                            // 0x0140(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_141[0x3];                                      // 0x0141(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         LockRadius;                                        // 0x0144(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_148[0x8];                                      // 0x0148(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ParticleModuleBeamTarget">();
	}
	static class UParticleModuleBeamTarget* GetDefaultObj()
	{
		return GetDefaultObjImpl<UParticleModuleBeamTarget>();
	}
};
static_assert(alignof(UParticleModuleBeamTarget) == 0x000008, "Wrong alignment on UParticleModuleBeamTarget");
static_assert(sizeof(UParticleModuleBeamTarget) == 0x000150, "Wrong size on UParticleModuleBeamTarget");
static_assert(offsetof(UParticleModuleBeamTarget, TargetMethod) == 0x000030, "Member 'UParticleModuleBeamTarget::TargetMethod' has a wrong offset!");
static_assert(offsetof(UParticleModuleBeamTarget, TargetName) == 0x000034, "Member 'UParticleModuleBeamTarget::TargetName' has a wrong offset!");
static_assert(offsetof(UParticleModuleBeamTarget, Target) == 0x000040, "Member 'UParticleModuleBeamTarget::Target' has a wrong offset!");
static_assert(offsetof(UParticleModuleBeamTarget, TargetTangentMethod) == 0x0000A4, "Member 'UParticleModuleBeamTarget::TargetTangentMethod' has a wrong offset!");
static_assert(offsetof(UParticleModuleBeamTarget, TargetTangent) == 0x0000A8, "Member 'UParticleModuleBeamTarget::TargetTangent' has a wrong offset!");
static_assert(offsetof(UParticleModuleBeamTarget, TargetStrength) == 0x000110, "Member 'UParticleModuleBeamTarget::TargetStrength' has a wrong offset!");
static_assert(offsetof(UParticleModuleBeamTarget, LockRadius) == 0x000144, "Member 'UParticleModuleBeamTarget::LockRadius' has a wrong offset!");

// Class Engine.ParticleModuleCollision
// 0x0190 (0x01C0 - 0x0030)
class UParticleModuleCollision final : public UParticleModuleCollisionBase
{
public:
	struct FRawDistributionVector                 DampingFactor;                                     // 0x0030(0x0060)(Edit, ContainsInstancedReference, NativeAccessSpecifierPublic)
	struct FRawDistributionVector                 DampingFactorRotation;                             // 0x0090(0x0060)(Edit, ContainsInstancedReference, NativeAccessSpecifierPublic)
	struct FRawDistributionFloat                  MaxCollisions;                                     // 0x00F0(0x0030)(Edit, ContainsInstancedReference, NativeAccessSpecifierPublic)
	EParticleCollisionComplete                    CollisionCompletionOption;                         // 0x0120(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_121[0x7];                                      // 0x0121(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<EObjectTypeQuery>                      CollisionTypes;                                    // 0x0128(0x0010)(Edit, ZeroConstructor, NativeAccessSpecifierPublic)
	uint8                                         Pad_138[0x8];                                      // 0x0138(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	uint8                                         bApplyPhysics : 1;                                 // 0x0140(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bIgnoreTriggerVolumes : 1;                         // 0x0140(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_141[0x7];                                      // 0x0141(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	struct FRawDistributionFloat                  ParticleMass;                                      // 0x0148(0x0030)(Edit, ContainsInstancedReference, NativeAccessSpecifierPublic)
	float                                         DirScalar;                                         // 0x0178(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bPawnsDoNotDecrementCount : 1;                     // 0x017C(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bOnlyVerticalNormalsDecrementCount : 1;            // 0x017C(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_17D[0x3];                                      // 0x017D(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         VerticalFudgeFactor;                               // 0x0180(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_184[0x4];                                      // 0x0184(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	struct FRawDistributionFloat                  DelayAmount;                                       // 0x0188(0x0030)(Edit, ContainsInstancedReference, NativeAccessSpecifierPublic)
	uint8                                         bDropDetail : 1;                                   // 0x01B8(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bCollideOnlyIfVisible : 1;                         // 0x01B8(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bIgnoreSourceActor : 1;                            // 0x01B8(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_1B9[0x3];                                      // 0x01B9(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         MaxCollisionDistance;                              // 0x01BC(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ParticleModuleCollision">();
	}
	static class UParticleModuleCollision* GetDefaultObj()
	{
		return GetDefaultObjImpl<UParticleModuleCollision>();
	}
};
static_assert(alignof(UParticleModuleCollision) == 0x000008, "Wrong alignment on UParticleModuleCollision");
static_assert(sizeof(UParticleModuleCollision) == 0x0001C0, "Wrong size on UParticleModuleCollision");
static_assert(offsetof(UParticleModuleCollision, DampingFactor) == 0x000030, "Member 'UParticleModuleCollision::DampingFactor' has a wrong offset!");
static_assert(offsetof(UParticleModuleCollision, DampingFactorRotation) == 0x000090, "Member 'UParticleModuleCollision::DampingFactorRotation' has a wrong offset!");
static_assert(offsetof(UParticleModuleCollision, MaxCollisions) == 0x0000F0, "Member 'UParticleModuleCollision::MaxCollisions' has a wrong offset!");
static_assert(offsetof(UParticleModuleCollision, CollisionCompletionOption) == 0x000120, "Member 'UParticleModuleCollision::CollisionCompletionOption' has a wrong offset!");
static_assert(offsetof(UParticleModuleCollision, CollisionTypes) == 0x000128, "Member 'UParticleModuleCollision::CollisionTypes' has a wrong offset!");
static_assert(offsetof(UParticleModuleCollision, ParticleMass) == 0x000148, "Member 'UParticleModuleCollision::ParticleMass' has a wrong offset!");
static_assert(offsetof(UParticleModuleCollision, DirScalar) == 0x000178, "Member 'UParticleModuleCollision::DirScalar' has a wrong offset!");
static_assert(offsetof(UParticleModuleCollision, VerticalFudgeFactor) == 0x000180, "Member 'UParticleModuleCollision::VerticalFudgeFactor' has a wrong offset!");
static_assert(offsetof(UParticleModuleCollision, DelayAmount) == 0x000188, "Member 'UParticleModuleCollision::DelayAmount' has a wrong offset!");
static_assert(offsetof(UParticleModuleCollision, MaxCollisionDistance) == 0x0001BC, "Member 'UParticleModuleCollision::MaxCollisionDistance' has a wrong offset!");

// Class Engine.CurveEdPresetCurve
// 0x0000 (0x0028 - 0x0028)
class UCurveEdPresetCurve final : public UObject
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"CurveEdPresetCurve">();
	}
	static class UCurveEdPresetCurve* GetDefaultObj()
	{
		return GetDefaultObjImpl<UCurveEdPresetCurve>();
	}
};
static_assert(alignof(UCurveEdPresetCurve) == 0x000008, "Wrong alignment on UCurveEdPresetCurve");
static_assert(sizeof(UCurveEdPresetCurve) == 0x000028, "Wrong size on UCurveEdPresetCurve");

// Class Engine.ParticleModuleColorOverLife
// 0x0098 (0x00C8 - 0x0030)
class UParticleModuleColorOverLife final : public UParticleModuleColorBase
{
public:
	struct FRawDistributionVector                 ColorOverLife;                                     // 0x0030(0x0060)(Edit, ContainsInstancedReference, NativeAccessSpecifierPublic)
	struct FRawDistributionFloat                  AlphaOverLife;                                     // 0x0090(0x0030)(Edit, ContainsInstancedReference, NativeAccessSpecifierPublic)
	uint8                                         bClampAlpha : 1;                                   // 0x00C0(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_C1[0x7];                                       // 0x00C1(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ParticleModuleColorOverLife">();
	}
	static class UParticleModuleColorOverLife* GetDefaultObj()
	{
		return GetDefaultObjImpl<UParticleModuleColorOverLife>();
	}
};
static_assert(alignof(UParticleModuleColorOverLife) == 0x000008, "Wrong alignment on UParticleModuleColorOverLife");
static_assert(sizeof(UParticleModuleColorOverLife) == 0x0000C8, "Wrong size on UParticleModuleColorOverLife");
static_assert(offsetof(UParticleModuleColorOverLife, ColorOverLife) == 0x000030, "Member 'UParticleModuleColorOverLife::ColorOverLife' has a wrong offset!");
static_assert(offsetof(UParticleModuleColorOverLife, AlphaOverLife) == 0x000090, "Member 'UParticleModuleColorOverLife::AlphaOverLife' has a wrong offset!");

// Class Engine.ParticleModuleEventGenerator
// 0x0010 (0x0040 - 0x0030)
class UParticleModuleEventGenerator final : public UParticleModuleEventBase
{
public:
	TArray<struct FParticleEvent_GenerateInfo>    Events;                                            // 0x0030(0x0010)(Edit, ExportObject, ZeroConstructor, NoClear, ContainsInstancedReference, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ParticleModuleEventGenerator">();
	}
	static class UParticleModuleEventGenerator* GetDefaultObj()
	{
		return GetDefaultObjImpl<UParticleModuleEventGenerator>();
	}
};
static_assert(alignof(UParticleModuleEventGenerator) == 0x000008, "Wrong alignment on UParticleModuleEventGenerator");
static_assert(sizeof(UParticleModuleEventGenerator) == 0x000040, "Wrong size on UParticleModuleEventGenerator");
static_assert(offsetof(UParticleModuleEventGenerator, Events) == 0x000030, "Member 'UParticleModuleEventGenerator::Events' has a wrong offset!");

// Class Engine.ParticleModuleEventReceiverKillParticles
// 0x0008 (0x0048 - 0x0040)
class UParticleModuleEventReceiverKillParticles final : public UParticleModuleEventReceiverBase
{
public:
	uint8                                         bStopSpawning : 1;                                 // 0x0040(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_41[0x7];                                       // 0x0041(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ParticleModuleEventReceiverKillParticles">();
	}
	static class UParticleModuleEventReceiverKillParticles* GetDefaultObj()
	{
		return GetDefaultObjImpl<UParticleModuleEventReceiverKillParticles>();
	}
};
static_assert(alignof(UParticleModuleEventReceiverKillParticles) == 0x000008, "Wrong alignment on UParticleModuleEventReceiverKillParticles");
static_assert(sizeof(UParticleModuleEventReceiverKillParticles) == 0x000048, "Wrong size on UParticleModuleEventReceiverKillParticles");

// Class Engine.DataDrivenConsoleVariableSettings
// 0x0038 (0x0070 - 0x0038)
class UDataDrivenConsoleVariableSettings final : public UDeveloperSettings
{
public:
	uint8                                         Pad_38[0x18];                                      // 0x0038(0x0018)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<struct FDataDrivenConsoleVariable>     CVarsArray;                                        // 0x0050(0x0010)(Edit, ZeroConstructor, Config, NativeAccessSpecifierPublic)
	uint8                                         Pad_60[0x10];                                      // 0x0060(0x0010)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"DataDrivenConsoleVariableSettings">();
	}
	static class UDataDrivenConsoleVariableSettings* GetDefaultObj()
	{
		return GetDefaultObjImpl<UDataDrivenConsoleVariableSettings>();
	}
};
static_assert(alignof(UDataDrivenConsoleVariableSettings) == 0x000008, "Wrong alignment on UDataDrivenConsoleVariableSettings");
static_assert(sizeof(UDataDrivenConsoleVariableSettings) == 0x000070, "Wrong size on UDataDrivenConsoleVariableSettings");
static_assert(offsetof(UDataDrivenConsoleVariableSettings, CVarsArray) == 0x000050, "Member 'UDataDrivenConsoleVariableSettings::CVarsArray' has a wrong offset!");

// Class Engine.ParticleModuleEventSendToGame
// 0x0000 (0x0028 - 0x0028)
class UParticleModuleEventSendToGame final : public UObject
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ParticleModuleEventSendToGame">();
	}
	static class UParticleModuleEventSendToGame* GetDefaultObj()
	{
		return GetDefaultObjImpl<UParticleModuleEventSendToGame>();
	}
};
static_assert(alignof(UParticleModuleEventSendToGame) == 0x000008, "Wrong alignment on UParticleModuleEventSendToGame");
static_assert(sizeof(UParticleModuleEventSendToGame) == 0x000028, "Wrong size on UParticleModuleEventSendToGame");

// Class Engine.ParticleModuleLifetimeBase
// 0x0000 (0x0030 - 0x0030)
class UParticleModuleLifetimeBase : public UParticleModule
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ParticleModuleLifetimeBase">();
	}
	static class UParticleModuleLifetimeBase* GetDefaultObj()
	{
		return GetDefaultObjImpl<UParticleModuleLifetimeBase>();
	}
};
static_assert(alignof(UParticleModuleLifetimeBase) == 0x000008, "Wrong alignment on UParticleModuleLifetimeBase");
static_assert(sizeof(UParticleModuleLifetimeBase) == 0x000030, "Wrong size on UParticleModuleLifetimeBase");

// Class Engine.ParticleModuleLifetime
// 0x0030 (0x0060 - 0x0030)
class UParticleModuleLifetime : public UParticleModuleLifetimeBase
{
public:
	struct FRawDistributionFloat                  Lifetime;                                          // 0x0030(0x0030)(Edit, ContainsInstancedReference, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ParticleModuleLifetime">();
	}
	static class UParticleModuleLifetime* GetDefaultObj()
	{
		return GetDefaultObjImpl<UParticleModuleLifetime>();
	}
};
static_assert(alignof(UParticleModuleLifetime) == 0x000008, "Wrong alignment on UParticleModuleLifetime");
static_assert(sizeof(UParticleModuleLifetime) == 0x000060, "Wrong size on UParticleModuleLifetime");
static_assert(offsetof(UParticleModuleLifetime, Lifetime) == 0x000030, "Member 'UParticleModuleLifetime::Lifetime' has a wrong offset!");

// Class Engine.ParticleModuleLifetime_Seeded
// 0x0020 (0x0080 - 0x0060)
class UParticleModuleLifetime_Seeded final : public UParticleModuleLifetime
{
public:
	struct FParticleRandomSeedInfo                RandomSeedInfo;                                    // 0x0060(0x0020)(Edit, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ParticleModuleLifetime_Seeded">();
	}
	static class UParticleModuleLifetime_Seeded* GetDefaultObj()
	{
		return GetDefaultObjImpl<UParticleModuleLifetime_Seeded>();
	}
};
static_assert(alignof(UParticleModuleLifetime_Seeded) == 0x000008, "Wrong alignment on UParticleModuleLifetime_Seeded");
static_assert(sizeof(UParticleModuleLifetime_Seeded) == 0x000080, "Wrong size on UParticleModuleLifetime_Seeded");
static_assert(offsetof(UParticleModuleLifetime_Seeded, RandomSeedInfo) == 0x000060, "Member 'UParticleModuleLifetime_Seeded::RandomSeedInfo' has a wrong offset!");

// Class Engine.InputDeviceTriggerFeedbackProperty
// 0x0078 (0x00B8 - 0x0040)
class UInputDeviceTriggerFeedbackProperty final : public UInputDeviceTriggerEffect
{
public:
	struct FDeviceTriggerFeedbackData             TriggerData;                                       // 0x0040(0x0010)(Edit, BlueprintVisible, NoDestructor, NativeAccessSpecifierPublic)
	TMap<class FName, struct FDeviceTriggerFeedbackData> DeviceOverrideData;                         // 0x0050(0x0050)(Edit, BlueprintVisible, NativeAccessSpecifierPublic)
	uint8                                         Pad_A0[0x18];                                      // 0x00A0(0x0018)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"InputDeviceTriggerFeedbackProperty">();
	}
	static class UInputDeviceTriggerFeedbackProperty* GetDefaultObj()
	{
		return GetDefaultObjImpl<UInputDeviceTriggerFeedbackProperty>();
	}
};
static_assert(alignof(UInputDeviceTriggerFeedbackProperty) == 0x000008, "Wrong alignment on UInputDeviceTriggerFeedbackProperty");
static_assert(sizeof(UInputDeviceTriggerFeedbackProperty) == 0x0000B8, "Wrong size on UInputDeviceTriggerFeedbackProperty");
static_assert(offsetof(UInputDeviceTriggerFeedbackProperty, TriggerData) == 0x000040, "Member 'UInputDeviceTriggerFeedbackProperty::TriggerData' has a wrong offset!");
static_assert(offsetof(UInputDeviceTriggerFeedbackProperty, DeviceOverrideData) == 0x000050, "Member 'UInputDeviceTriggerFeedbackProperty::DeviceOverrideData' has a wrong offset!");

// Class Engine.InputDeviceSubsystem
// 0x0168 (0x0198 - 0x0030)
class UInputDeviceSubsystem final : public UEngineSubsystem
{
public:
	uint8                                         Pad_30[0x8];                                       // 0x0030(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	TMulticastInlineDelegate<void(const struct FPlatformUserId& UserId, const struct FInputDeviceId& DeviceID)> OnInputHardwareDeviceChanged; // 0x0038(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	TSet<struct FActiveDeviceProperty>            ActiveProperties;                                  // 0x0048(0x0050)(Transient, Protected, NativeAccessSpecifierProtected)
	TSet<struct FInputDevicePropertyHandle>       PropertiesPendingRemoval;                          // 0x0098(0x0050)(Transient, Protected, NativeAccessSpecifierProtected)
	uint8                                         Pad_E8[0xB0];                                      // 0x00E8(0x00B0)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	struct FInputDevicePropertyHandle ActivateDevicePropertyOfClass(TSubclassOf<class UInputDeviceProperty> PropertyClass, const struct FActivateDevicePropertyParams& params);
	void RemoveAllDeviceProperties();
	void RemoveDevicePropertyByHandle(const struct FInputDevicePropertyHandle& HandleToRemove);
	void RemoveDevicePropertyHandles(const TSet<struct FInputDevicePropertyHandle>& HandlesToRemove);

	class UInputDeviceProperty* GetActiveDeviceProperty(const struct FInputDevicePropertyHandle& Handle) const;
	struct FHardwareDeviceIdentifier GetInputDeviceHardwareIdentifier(const struct FInputDeviceId& InputDevice) const;
	struct FHardwareDeviceIdentifier GetMostRecentlyUsedHardwareDevice(const struct FPlatformUserId& InUserId) const;
	bool IsPropertyActive(const struct FInputDevicePropertyHandle& Handle) const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"InputDeviceSubsystem">();
	}
	static class UInputDeviceSubsystem* GetDefaultObj()
	{
		return GetDefaultObjImpl<UInputDeviceSubsystem>();
	}
};
static_assert(alignof(UInputDeviceSubsystem) == 0x000008, "Wrong alignment on UInputDeviceSubsystem");
static_assert(sizeof(UInputDeviceSubsystem) == 0x000198, "Wrong size on UInputDeviceSubsystem");
static_assert(offsetof(UInputDeviceSubsystem, OnInputHardwareDeviceChanged) == 0x000038, "Member 'UInputDeviceSubsystem::OnInputHardwareDeviceChanged' has a wrong offset!");
static_assert(offsetof(UInputDeviceSubsystem, ActiveProperties) == 0x000048, "Member 'UInputDeviceSubsystem::ActiveProperties' has a wrong offset!");
static_assert(offsetof(UInputDeviceSubsystem, PropertiesPendingRemoval) == 0x000098, "Member 'UInputDeviceSubsystem::PropertiesPendingRemoval' has a wrong offset!");

// Class Engine.ParticleModuleLocation
// 0x0068 (0x0098 - 0x0030)
class UParticleModuleLocation : public UParticleModuleLocationBase
{
public:
	struct FRawDistributionVector                 StartLocation;                                     // 0x0030(0x0060)(Edit, ContainsInstancedReference, NativeAccessSpecifierPublic)
	float                                         DistributeOverNPoints;                             // 0x0090(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         DistributeThreshold;                               // 0x0094(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ParticleModuleLocation">();
	}
	static class UParticleModuleLocation* GetDefaultObj()
	{
		return GetDefaultObjImpl<UParticleModuleLocation>();
	}
};
static_assert(alignof(UParticleModuleLocation) == 0x000008, "Wrong alignment on UParticleModuleLocation");
static_assert(sizeof(UParticleModuleLocation) == 0x000098, "Wrong size on UParticleModuleLocation");
static_assert(offsetof(UParticleModuleLocation, StartLocation) == 0x000030, "Member 'UParticleModuleLocation::StartLocation' has a wrong offset!");
static_assert(offsetof(UParticleModuleLocation, DistributeOverNPoints) == 0x000090, "Member 'UParticleModuleLocation::DistributeOverNPoints' has a wrong offset!");
static_assert(offsetof(UParticleModuleLocation, DistributeThreshold) == 0x000094, "Member 'UParticleModuleLocation::DistributeThreshold' has a wrong offset!");

// Class Engine.ParticleModuleLocationBoneSocket
// 0x0050 (0x0080 - 0x0030)
class UParticleModuleLocationBoneSocket final : public UParticleModuleLocationBase
{
public:
	ELocationBoneSocketSource                     SourceType;                                        // 0x0030(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_31[0x7];                                       // 0x0031(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	struct FVector                                UniversalOffset;                                   // 0x0038(0x0018)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TArray<struct FLocationBoneSocketInfo>        SourceLocations;                                   // 0x0050(0x0010)(Edit, ZeroConstructor, NativeAccessSpecifierPublic)
	ELocationBoneSocketSelectionMethod            SelectionMethod;                                   // 0x0060(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_61[0x3];                                       // 0x0061(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	uint8                                         bUpdatePositionEachFrame : 1;                      // 0x0064(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bOrientMeshEmitters : 1;                           // 0x0064(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bInheritBoneVelocity : 1;                          // 0x0064(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_65[0x3];                                       // 0x0065(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         InheritVelocityScale;                              // 0x0068(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FName                                   SkelMeshActorParamName;                            // 0x006C(0x0008)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         NumPreSelectedIndices;                             // 0x0074(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_78[0x8];                                       // 0x0078(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ParticleModuleLocationBoneSocket">();
	}
	static class UParticleModuleLocationBoneSocket* GetDefaultObj()
	{
		return GetDefaultObjImpl<UParticleModuleLocationBoneSocket>();
	}
};
static_assert(alignof(UParticleModuleLocationBoneSocket) == 0x000008, "Wrong alignment on UParticleModuleLocationBoneSocket");
static_assert(sizeof(UParticleModuleLocationBoneSocket) == 0x000080, "Wrong size on UParticleModuleLocationBoneSocket");
static_assert(offsetof(UParticleModuleLocationBoneSocket, SourceType) == 0x000030, "Member 'UParticleModuleLocationBoneSocket::SourceType' has a wrong offset!");
static_assert(offsetof(UParticleModuleLocationBoneSocket, UniversalOffset) == 0x000038, "Member 'UParticleModuleLocationBoneSocket::UniversalOffset' has a wrong offset!");
static_assert(offsetof(UParticleModuleLocationBoneSocket, SourceLocations) == 0x000050, "Member 'UParticleModuleLocationBoneSocket::SourceLocations' has a wrong offset!");
static_assert(offsetof(UParticleModuleLocationBoneSocket, SelectionMethod) == 0x000060, "Member 'UParticleModuleLocationBoneSocket::SelectionMethod' has a wrong offset!");
static_assert(offsetof(UParticleModuleLocationBoneSocket, InheritVelocityScale) == 0x000068, "Member 'UParticleModuleLocationBoneSocket::InheritVelocityScale' has a wrong offset!");
static_assert(offsetof(UParticleModuleLocationBoneSocket, SkelMeshActorParamName) == 0x00006C, "Member 'UParticleModuleLocationBoneSocket::SkelMeshActorParamName' has a wrong offset!");
static_assert(offsetof(UParticleModuleLocationBoneSocket, NumPreSelectedIndices) == 0x000074, "Member 'UParticleModuleLocationBoneSocket::NumPreSelectedIndices' has a wrong offset!");

// Class Engine.ParticleModuleLocationDirect
// 0x0180 (0x01B0 - 0x0030)
class UParticleModuleLocationDirect final : public UParticleModuleLocationBase
{
public:
	struct FRawDistributionVector                 Location;                                          // 0x0030(0x0060)(Edit, ContainsInstancedReference, NativeAccessSpecifierPublic)
	struct FRawDistributionVector                 LocationOffset;                                    // 0x0090(0x0060)(Edit, ContainsInstancedReference, NativeAccessSpecifierPublic)
	struct FRawDistributionVector                 ScaleFactor;                                       // 0x00F0(0x0060)(Edit, ContainsInstancedReference, NativeAccessSpecifierPublic)
	struct FRawDistributionVector                 Direction;                                         // 0x0150(0x0060)(Edit, ContainsInstancedReference, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ParticleModuleLocationDirect">();
	}
	static class UParticleModuleLocationDirect* GetDefaultObj()
	{
		return GetDefaultObjImpl<UParticleModuleLocationDirect>();
	}
};
static_assert(alignof(UParticleModuleLocationDirect) == 0x000008, "Wrong alignment on UParticleModuleLocationDirect");
static_assert(sizeof(UParticleModuleLocationDirect) == 0x0001B0, "Wrong size on UParticleModuleLocationDirect");
static_assert(offsetof(UParticleModuleLocationDirect, Location) == 0x000030, "Member 'UParticleModuleLocationDirect::Location' has a wrong offset!");
static_assert(offsetof(UParticleModuleLocationDirect, LocationOffset) == 0x000090, "Member 'UParticleModuleLocationDirect::LocationOffset' has a wrong offset!");
static_assert(offsetof(UParticleModuleLocationDirect, ScaleFactor) == 0x0000F0, "Member 'UParticleModuleLocationDirect::ScaleFactor' has a wrong offset!");
static_assert(offsetof(UParticleModuleLocationDirect, Direction) == 0x000150, "Member 'UParticleModuleLocationDirect::Direction' has a wrong offset!");

// Class Engine.ParticleModuleLocationEmitter
// 0x0020 (0x0050 - 0x0030)
class UParticleModuleLocationEmitter final : public UParticleModuleLocationBase
{
public:
	class FName                                   EmitterName;                                       // 0x0030(0x0008)(Edit, ExportObject, ZeroConstructor, NoClear, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	ELocationEmitterSelectionMethod               SelectionMethod;                                   // 0x0038(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_39[0x3];                                       // 0x0039(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	uint8                                         InheritSourceVelocity : 1;                         // 0x003C(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_3D[0x3];                                       // 0x003D(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         InheritSourceVelocityScale;                        // 0x0040(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bInheritSourceRotation : 1;                        // 0x0044(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_45[0x3];                                       // 0x0045(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         InheritSourceRotationScale;                        // 0x0048(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_4C[0x4];                                       // 0x004C(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ParticleModuleLocationEmitter">();
	}
	static class UParticleModuleLocationEmitter* GetDefaultObj()
	{
		return GetDefaultObjImpl<UParticleModuleLocationEmitter>();
	}
};
static_assert(alignof(UParticleModuleLocationEmitter) == 0x000008, "Wrong alignment on UParticleModuleLocationEmitter");
static_assert(sizeof(UParticleModuleLocationEmitter) == 0x000050, "Wrong size on UParticleModuleLocationEmitter");
static_assert(offsetof(UParticleModuleLocationEmitter, EmitterName) == 0x000030, "Member 'UParticleModuleLocationEmitter::EmitterName' has a wrong offset!");
static_assert(offsetof(UParticleModuleLocationEmitter, SelectionMethod) == 0x000038, "Member 'UParticleModuleLocationEmitter::SelectionMethod' has a wrong offset!");
static_assert(offsetof(UParticleModuleLocationEmitter, InheritSourceVelocityScale) == 0x000040, "Member 'UParticleModuleLocationEmitter::InheritSourceVelocityScale' has a wrong offset!");
static_assert(offsetof(UParticleModuleLocationEmitter, InheritSourceRotationScale) == 0x000048, "Member 'UParticleModuleLocationEmitter::InheritSourceRotationScale' has a wrong offset!");

// Class Engine.SpringArmComponent
// 0x0100 (0x03A0 - 0x02A0)
class USpringArmComponent final : public USceneComponent
{
public:
	float                                         TargetArmLength;                                   // 0x02A0(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_2A4[0x4];                                      // 0x02A4(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	struct FVector                                SocketOffset;                                      // 0x02A8(0x0018)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector                                TargetOffset;                                      // 0x02C0(0x0018)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         ProbeSize;                                         // 0x02D8(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	ECollisionChannel                             ProbeChannel;                                      // 0x02DC(0x0001)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_2DD[0x3];                                      // 0x02DD(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	uint8                                         bDoCollisionTest : 1;                              // 0x02E0(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bUsePawnControlRotation : 1;                       // 0x02E0(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bInheritPitch : 1;                                 // 0x02E0(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bInheritYaw : 1;                                   // 0x02E0(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bInheritRoll : 1;                                  // 0x02E0(0x0001)(BitIndex: 0x04, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bEnableCameraLag : 1;                              // 0x02E0(0x0001)(BitIndex: 0x05, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bEnableCameraRotationLag : 1;                      // 0x02E0(0x0001)(BitIndex: 0x06, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bUseCameraLagSubstepping : 1;                      // 0x02E0(0x0001)(BitIndex: 0x07, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bDrawDebugLagMarkers : 1;                          // 0x02E1(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_2E2[0x2];                                      // 0x02E2(0x0002)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         CameraLagSpeed;                                    // 0x02E4(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         CameraRotationLagSpeed;                            // 0x02E8(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         CameraLagMaxTimeStep;                              // 0x02EC(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         CameraLagMaxDistance;                              // 0x02F0(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bClampToMaxPhysicsDeltaTime : 1;                   // 0x02F4(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_2F5[0xAB];                                     // 0x02F5(0x00AB)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	struct FRotator GetTargetRotation() const;
	struct FVector GetUnfixedCameraPosition() const;
	bool IsCollisionFixApplied() const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"SpringArmComponent">();
	}
	static class USpringArmComponent* GetDefaultObj()
	{
		return GetDefaultObjImpl<USpringArmComponent>();
	}
};
static_assert(alignof(USpringArmComponent) == 0x000010, "Wrong alignment on USpringArmComponent");
static_assert(sizeof(USpringArmComponent) == 0x0003A0, "Wrong size on USpringArmComponent");
static_assert(offsetof(USpringArmComponent, TargetArmLength) == 0x0002A0, "Member 'USpringArmComponent::TargetArmLength' has a wrong offset!");
static_assert(offsetof(USpringArmComponent, SocketOffset) == 0x0002A8, "Member 'USpringArmComponent::SocketOffset' has a wrong offset!");
static_assert(offsetof(USpringArmComponent, TargetOffset) == 0x0002C0, "Member 'USpringArmComponent::TargetOffset' has a wrong offset!");
static_assert(offsetof(USpringArmComponent, ProbeSize) == 0x0002D8, "Member 'USpringArmComponent::ProbeSize' has a wrong offset!");
static_assert(offsetof(USpringArmComponent, ProbeChannel) == 0x0002DC, "Member 'USpringArmComponent::ProbeChannel' has a wrong offset!");
static_assert(offsetof(USpringArmComponent, CameraLagSpeed) == 0x0002E4, "Member 'USpringArmComponent::CameraLagSpeed' has a wrong offset!");
static_assert(offsetof(USpringArmComponent, CameraRotationLagSpeed) == 0x0002E8, "Member 'USpringArmComponent::CameraRotationLagSpeed' has a wrong offset!");
static_assert(offsetof(USpringArmComponent, CameraLagMaxTimeStep) == 0x0002EC, "Member 'USpringArmComponent::CameraLagMaxTimeStep' has a wrong offset!");
static_assert(offsetof(USpringArmComponent, CameraLagMaxDistance) == 0x0002F0, "Member 'USpringArmComponent::CameraLagMaxDistance' has a wrong offset!");

// Class Engine.ParticleModuleLocationEmitterDirect
// 0x0008 (0x0038 - 0x0030)
class UParticleModuleLocationEmitterDirect final : public UParticleModuleLocationBase
{
public:
	class FName                                   EmitterName;                                       // 0x0030(0x0008)(Edit, ExportObject, ZeroConstructor, NoClear, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ParticleModuleLocationEmitterDirect">();
	}
	static class UParticleModuleLocationEmitterDirect* GetDefaultObj()
	{
		return GetDefaultObjImpl<UParticleModuleLocationEmitterDirect>();
	}
};
static_assert(alignof(UParticleModuleLocationEmitterDirect) == 0x000008, "Wrong alignment on UParticleModuleLocationEmitterDirect");
static_assert(sizeof(UParticleModuleLocationEmitterDirect) == 0x000038, "Wrong size on UParticleModuleLocationEmitterDirect");
static_assert(offsetof(UParticleModuleLocationEmitterDirect, EmitterName) == 0x000030, "Member 'UParticleModuleLocationEmitterDirect::EmitterName' has a wrong offset!");

// Class Engine.ParticleModuleLocationPrimitiveCylinder
// 0x0070 (0x0138 - 0x00C8)
class UParticleModuleLocationPrimitiveCylinder : public UParticleModuleLocationPrimitiveBase
{
public:
	uint8                                         RadialVelocity : 1;                                // 0x00C8(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_C9[0x7];                                       // 0x00C9(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	struct FRawDistributionFloat                  StartRadius;                                       // 0x00D0(0x0030)(Edit, ContainsInstancedReference, NativeAccessSpecifierPublic)
	struct FRawDistributionFloat                  StartHeight;                                       // 0x0100(0x0030)(Edit, ContainsInstancedReference, NativeAccessSpecifierPublic)
	ECylinderHeightAxis                           HeightAxis;                                        // 0x0130(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_131[0x7];                                      // 0x0131(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ParticleModuleLocationPrimitiveCylinder">();
	}
	static class UParticleModuleLocationPrimitiveCylinder* GetDefaultObj()
	{
		return GetDefaultObjImpl<UParticleModuleLocationPrimitiveCylinder>();
	}
};
static_assert(alignof(UParticleModuleLocationPrimitiveCylinder) == 0x000008, "Wrong alignment on UParticleModuleLocationPrimitiveCylinder");
static_assert(sizeof(UParticleModuleLocationPrimitiveCylinder) == 0x000138, "Wrong size on UParticleModuleLocationPrimitiveCylinder");
static_assert(offsetof(UParticleModuleLocationPrimitiveCylinder, StartRadius) == 0x0000D0, "Member 'UParticleModuleLocationPrimitiveCylinder::StartRadius' has a wrong offset!");
static_assert(offsetof(UParticleModuleLocationPrimitiveCylinder, StartHeight) == 0x000100, "Member 'UParticleModuleLocationPrimitiveCylinder::StartHeight' has a wrong offset!");
static_assert(offsetof(UParticleModuleLocationPrimitiveCylinder, HeightAxis) == 0x000130, "Member 'UParticleModuleLocationPrimitiveCylinder::HeightAxis' has a wrong offset!");

// Class Engine.ParticleModuleLocationPrimitiveCylinder_Seeded
// 0x0020 (0x0158 - 0x0138)
class UParticleModuleLocationPrimitiveCylinder_Seeded final : public UParticleModuleLocationPrimitiveCylinder
{
public:
	struct FParticleRandomSeedInfo                RandomSeedInfo;                                    // 0x0138(0x0020)(Edit, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ParticleModuleLocationPrimitiveCylinder_Seeded">();
	}
	static class UParticleModuleLocationPrimitiveCylinder_Seeded* GetDefaultObj()
	{
		return GetDefaultObjImpl<UParticleModuleLocationPrimitiveCylinder_Seeded>();
	}
};
static_assert(alignof(UParticleModuleLocationPrimitiveCylinder_Seeded) == 0x000008, "Wrong alignment on UParticleModuleLocationPrimitiveCylinder_Seeded");
static_assert(sizeof(UParticleModuleLocationPrimitiveCylinder_Seeded) == 0x000158, "Wrong size on UParticleModuleLocationPrimitiveCylinder_Seeded");
static_assert(offsetof(UParticleModuleLocationPrimitiveCylinder_Seeded, RandomSeedInfo) == 0x000138, "Member 'UParticleModuleLocationPrimitiveCylinder_Seeded::RandomSeedInfo' has a wrong offset!");

// Class Engine.GameModeBase
// 0x00A0 (0x0340 - 0x02A0)
class AGameModeBase : public AInfo
{
public:
	class FString                                 OptionsString;                                     // 0x02A0(0x0010)(BlueprintVisible, BlueprintReadOnly, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TSubclassOf<class AGameSession>               GameSessionClass;                                  // 0x02B0(0x0008)(Edit, BlueprintVisible, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TSubclassOf<class AGameStateBase>             GameStateClass;                                    // 0x02B8(0x0008)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, NoClear, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TSubclassOf<class APlayerController>          PlayerControllerClass;                             // 0x02C0(0x0008)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, NoClear, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TSubclassOf<class APlayerState>               PlayerStateClass;                                  // 0x02C8(0x0008)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, NoClear, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TSubclassOf<class AHUD>                       HUDClass;                                          // 0x02D0(0x0008)(Edit, BlueprintVisible, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TSubclassOf<class APawn>                      DefaultPawnClass;                                  // 0x02D8(0x0008)(Edit, BlueprintVisible, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TSubclassOf<class ASpectatorPawn>             SpectatorClass;                                    // 0x02E0(0x0008)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, NoClear, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TSubclassOf<class APlayerController>          ReplaySpectatorPlayerControllerClass;              // 0x02E8(0x0008)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, NoClear, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TSubclassOf<class AServerStatReplicator>      ServerStatReplicatorClass;                         // 0x02F0(0x0008)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, NoClear, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AGameSession*                           GameSession;                                       // 0x02F8(0x0008)(ZeroConstructor, Transient, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AGameStateBase*                         GameState;                                         // 0x0300(0x0008)(ZeroConstructor, Transient, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AServerStatReplicator*                  ServerStatReplicator;                              // 0x0308(0x0008)(ZeroConstructor, Transient, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FText                                   DefaultPlayerName;                                 // 0x0310(0x0018)(Edit, NativeAccessSpecifierPublic)
	uint8                                         bUseSeamlessTravel : 1;                            // 0x0328(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bStartPlayersAsSpectators : 1;                     // 0x0328(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
	uint8                                         bPauseable : 1;                                    // 0x0328(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
	uint8                                         Pad_329[0x17];                                     // 0x0329(0x0017)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	bool CanSpectate(class APlayerController* Viewer, class APlayerState* ViewTarget);
	void ChangeName(class AController* Controller, const class FString& NewName, bool bNameChange);
	class AActor* ChoosePlayerStart(class AController* Player);
	class AActor* FindPlayerStart(class AController* Player, const class FString& IncomingName);
	class UClass* GetDefaultPawnClassForController(class AController* InController);
	int32 GetNumPlayers();
	int32 GetNumSpectators();
	void HandleStartingNewPlayer(class APlayerController* NewPlayer);
	void InitializeHUDForPlayer(class APlayerController* NewPlayer);
	void InitStartSpot(class AActor* StartSpot, class AController* NewPlayer);
	class AActor* K2_FindPlayerStart(class AController* Player, const class FString& IncomingName);
	void K2_OnChangeName(class AController* Other, const class FString& NewName, bool bNameChange);
	void K2_OnLogout(class AController* ExitingController);
	void K2_OnRestartPlayer(class AController* NewPlayer);
	void K2_OnSwapPlayerControllers(class APlayerController* OldPC, class APlayerController* NewPC);
	void K2_PostLogin(class APlayerController* NewPlayer);
	bool PlayerCanRestart(class APlayerController* Player);
	void ResetLevel();
	void RestartPlayer(class AController* NewPlayer);
	void RestartPlayerAtPlayerStart(class AController* NewPlayer, class AActor* StartSpot);
	void RestartPlayerAtTransform(class AController* NewPlayer, const struct FTransform& SpawnTransform);
	void ReturnToMainMenuHost();
	bool ShouldReset(class AActor* ActorToReset);
	class APawn* SpawnDefaultPawnAtTransform(class AController* NewPlayer, const struct FTransform& SpawnTransform);
	class APawn* SpawnDefaultPawnFor(class AController* NewPlayer, class AActor* StartSpot);
	void StartPlay();

	bool HasMatchEnded() const;
	bool HasMatchStarted() const;
	bool MustSpectate(class APlayerController* NewPlayerController) const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"GameModeBase">();
	}
	static class AGameModeBase* GetDefaultObj()
	{
		return GetDefaultObjImpl<AGameModeBase>();
	}
};
static_assert(alignof(AGameModeBase) == 0x000008, "Wrong alignment on AGameModeBase");
static_assert(sizeof(AGameModeBase) == 0x000340, "Wrong size on AGameModeBase");
static_assert(offsetof(AGameModeBase, OptionsString) == 0x0002A0, "Member 'AGameModeBase::OptionsString' has a wrong offset!");
static_assert(offsetof(AGameModeBase, GameSessionClass) == 0x0002B0, "Member 'AGameModeBase::GameSessionClass' has a wrong offset!");
static_assert(offsetof(AGameModeBase, GameStateClass) == 0x0002B8, "Member 'AGameModeBase::GameStateClass' has a wrong offset!");
static_assert(offsetof(AGameModeBase, PlayerControllerClass) == 0x0002C0, "Member 'AGameModeBase::PlayerControllerClass' has a wrong offset!");
static_assert(offsetof(AGameModeBase, PlayerStateClass) == 0x0002C8, "Member 'AGameModeBase::PlayerStateClass' has a wrong offset!");
static_assert(offsetof(AGameModeBase, HUDClass) == 0x0002D0, "Member 'AGameModeBase::HUDClass' has a wrong offset!");
static_assert(offsetof(AGameModeBase, DefaultPawnClass) == 0x0002D8, "Member 'AGameModeBase::DefaultPawnClass' has a wrong offset!");
static_assert(offsetof(AGameModeBase, SpectatorClass) == 0x0002E0, "Member 'AGameModeBase::SpectatorClass' has a wrong offset!");
static_assert(offsetof(AGameModeBase, ReplaySpectatorPlayerControllerClass) == 0x0002E8, "Member 'AGameModeBase::ReplaySpectatorPlayerControllerClass' has a wrong offset!");
static_assert(offsetof(AGameModeBase, ServerStatReplicatorClass) == 0x0002F0, "Member 'AGameModeBase::ServerStatReplicatorClass' has a wrong offset!");
static_assert(offsetof(AGameModeBase, GameSession) == 0x0002F8, "Member 'AGameModeBase::GameSession' has a wrong offset!");
static_assert(offsetof(AGameModeBase, GameState) == 0x000300, "Member 'AGameModeBase::GameState' has a wrong offset!");
static_assert(offsetof(AGameModeBase, ServerStatReplicator) == 0x000308, "Member 'AGameModeBase::ServerStatReplicator' has a wrong offset!");
static_assert(offsetof(AGameModeBase, DefaultPlayerName) == 0x000310, "Member 'AGameModeBase::DefaultPlayerName' has a wrong offset!");

// Class Engine.GameMode
// 0x0048 (0x0388 - 0x0340)
class AGameMode final : public AGameModeBase
{
public:
	class FName                                   MatchState;                                        // 0x0340(0x0008)(ZeroConstructor, Transient, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         bDelayedStart : 1;                                 // 0x0348(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_349[0x3];                                      // 0x0349(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	int32                                         NumSpectators;                                     // 0x034C(0x0004)(BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         NumPlayers;                                        // 0x0350(0x0004)(BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         NumBots;                                           // 0x0354(0x0004)(BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         MinRespawnDelay;                                   // 0x0358(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         NumTravellingPlayers;                              // 0x035C(0x0004)(BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TSubclassOf<class ULocalMessage>              EngineMessageClass;                                // 0x0360(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TArray<class APlayerState*>                   InactivePlayerArray;                               // 0x0368(0x0010)(ZeroConstructor, UObjectWrapper, NativeAccessSpecifierPublic)
	float                                         InactivePlayerStateLifeSpan;                       // 0x0378(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	int32                                         MaxInactivePlayers;                                // 0x037C(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	bool                                          bHandleDedicatedServerReplays;                     // 0x0380(0x0001)(ZeroConstructor, Config, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_381[0x7];                                      // 0x0381(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void AbortMatch();
	void EndMatch();
	void K2_OnSetMatchState(class FName NewState);
	bool ReadyToEndMatch();
	bool ReadyToStartMatch();
	void RestartGame();
	void Say(const class FString& Msg);
	void StartMatch();

	class FName GetMatchState() const;
	bool IsMatchInProgress() const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"GameMode">();
	}
	static class AGameMode* GetDefaultObj()
	{
		return GetDefaultObjImpl<AGameMode>();
	}
};
static_assert(alignof(AGameMode) == 0x000008, "Wrong alignment on AGameMode");
static_assert(sizeof(AGameMode) == 0x000388, "Wrong size on AGameMode");
static_assert(offsetof(AGameMode, MatchState) == 0x000340, "Member 'AGameMode::MatchState' has a wrong offset!");
static_assert(offsetof(AGameMode, NumSpectators) == 0x00034C, "Member 'AGameMode::NumSpectators' has a wrong offset!");
static_assert(offsetof(AGameMode, NumPlayers) == 0x000350, "Member 'AGameMode::NumPlayers' has a wrong offset!");
static_assert(offsetof(AGameMode, NumBots) == 0x000354, "Member 'AGameMode::NumBots' has a wrong offset!");
static_assert(offsetof(AGameMode, MinRespawnDelay) == 0x000358, "Member 'AGameMode::MinRespawnDelay' has a wrong offset!");
static_assert(offsetof(AGameMode, NumTravellingPlayers) == 0x00035C, "Member 'AGameMode::NumTravellingPlayers' has a wrong offset!");
static_assert(offsetof(AGameMode, EngineMessageClass) == 0x000360, "Member 'AGameMode::EngineMessageClass' has a wrong offset!");
static_assert(offsetof(AGameMode, InactivePlayerArray) == 0x000368, "Member 'AGameMode::InactivePlayerArray' has a wrong offset!");
static_assert(offsetof(AGameMode, InactivePlayerStateLifeSpan) == 0x000378, "Member 'AGameMode::InactivePlayerStateLifeSpan' has a wrong offset!");
static_assert(offsetof(AGameMode, MaxInactivePlayers) == 0x00037C, "Member 'AGameMode::MaxInactivePlayers' has a wrong offset!");
static_assert(offsetof(AGameMode, bHandleDedicatedServerReplays) == 0x000380, "Member 'AGameMode::bHandleDedicatedServerReplays' has a wrong offset!");

// Class Engine.ParticleModuleLocationPrimitiveSphere_Seeded
// 0x0020 (0x0118 - 0x00F8)
class UParticleModuleLocationPrimitiveSphere_Seeded final : public UParticleModuleLocationPrimitiveSphere
{
public:
	struct FParticleRandomSeedInfo                RandomSeedInfo;                                    // 0x00F8(0x0020)(Edit, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ParticleModuleLocationPrimitiveSphere_Seeded">();
	}
	static class UParticleModuleLocationPrimitiveSphere_Seeded* GetDefaultObj()
	{
		return GetDefaultObjImpl<UParticleModuleLocationPrimitiveSphere_Seeded>();
	}
};
static_assert(alignof(UParticleModuleLocationPrimitiveSphere_Seeded) == 0x000008, "Wrong alignment on UParticleModuleLocationPrimitiveSphere_Seeded");
static_assert(sizeof(UParticleModuleLocationPrimitiveSphere_Seeded) == 0x000118, "Wrong size on UParticleModuleLocationPrimitiveSphere_Seeded");
static_assert(offsetof(UParticleModuleLocationPrimitiveSphere_Seeded, RandomSeedInfo) == 0x0000F8, "Member 'UParticleModuleLocationPrimitiveSphere_Seeded::RandomSeedInfo' has a wrong offset!");

// Class Engine.ParticleModuleLocationPrimitiveTriangle
// 0x00F0 (0x0120 - 0x0030)
class UParticleModuleLocationPrimitiveTriangle final : public UParticleModuleLocationBase
{
public:
	struct FRawDistributionVector                 StartOffset;                                       // 0x0030(0x0060)(Edit, ContainsInstancedReference, NativeAccessSpecifierPublic)
	struct FRawDistributionFloat                  Height;                                            // 0x0090(0x0030)(Edit, ContainsInstancedReference, NativeAccessSpecifierPublic)
	struct FRawDistributionFloat                  Angle;                                             // 0x00C0(0x0030)(Edit, ContainsInstancedReference, NativeAccessSpecifierPublic)
	struct FRawDistributionFloat                  Thickness;                                         // 0x00F0(0x0030)(Edit, ContainsInstancedReference, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ParticleModuleLocationPrimitiveTriangle">();
	}
	static class UParticleModuleLocationPrimitiveTriangle* GetDefaultObj()
	{
		return GetDefaultObjImpl<UParticleModuleLocationPrimitiveTriangle>();
	}
};
static_assert(alignof(UParticleModuleLocationPrimitiveTriangle) == 0x000008, "Wrong alignment on UParticleModuleLocationPrimitiveTriangle");
static_assert(sizeof(UParticleModuleLocationPrimitiveTriangle) == 0x000120, "Wrong size on UParticleModuleLocationPrimitiveTriangle");
static_assert(offsetof(UParticleModuleLocationPrimitiveTriangle, StartOffset) == 0x000030, "Member 'UParticleModuleLocationPrimitiveTriangle::StartOffset' has a wrong offset!");
static_assert(offsetof(UParticleModuleLocationPrimitiveTriangle, Height) == 0x000090, "Member 'UParticleModuleLocationPrimitiveTriangle::Height' has a wrong offset!");
static_assert(offsetof(UParticleModuleLocationPrimitiveTriangle, Angle) == 0x0000C0, "Member 'UParticleModuleLocationPrimitiveTriangle::Angle' has a wrong offset!");
static_assert(offsetof(UParticleModuleLocationPrimitiveTriangle, Thickness) == 0x0000F0, "Member 'UParticleModuleLocationPrimitiveTriangle::Thickness' has a wrong offset!");

// Class Engine.AnimSingleNodeInstance
// 0x0010 (0x0360 - 0x0350)
class UAnimSingleNodeInstance final : public UAnimInstance
{
public:
	class UAnimationAsset*                        CurrentAsset;                                      // 0x0348(0x0008)(ZeroConstructor, Transient, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TDelegate<void()>                             PostEvaluateAnimEvent;                             // 0x0350(0x0010)(ZeroConstructor, Transient, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

public:
	float GetLength();
	const class UMirrorDataTable* GetMirrorDataTable();
	void PlayAnim(bool bIsLooping, float InPlayRate, float InStartPosition);
	void SetAnimationAsset(class UAnimationAsset* NewAsset, bool bIsLooping, float InPlayRate);
	void SetBlendSpacePosition(const struct FVector& InPosition);
	void SetLooping(bool bIsLooping);
	void SetMirrorDataTable(const class UMirrorDataTable* MirrorDataTable);
	void SetPlaying(bool bIsPlaying);
	void SetPlayRate(float InPlayRate);
	void SetPosition(float InPosition, bool bFireNotifies);
	void SetPositionWithPreviousTime(float InPosition, float InPreviousTime, bool bFireNotifies);
	void SetPreviewCurveOverride(const class FName& PoseName, float Value, bool bRemoveIfZero);
	void SetReverse(bool bInReverse);
	void StopAnim();

	class UAnimationAsset* GetAnimationAsset() const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AnimSingleNodeInstance">();
	}
	static class UAnimSingleNodeInstance* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAnimSingleNodeInstance>();
	}
};
static_assert(alignof(UAnimSingleNodeInstance) == 0x000010, "Wrong alignment on UAnimSingleNodeInstance");
static_assert(sizeof(UAnimSingleNodeInstance) == 0x000360, "Wrong size on UAnimSingleNodeInstance");
static_assert(offsetof(UAnimSingleNodeInstance, CurrentAsset) == 0x000348, "Member 'UAnimSingleNodeInstance::CurrentAsset' has a wrong offset!");
static_assert(offsetof(UAnimSingleNodeInstance, PostEvaluateAnimEvent) == 0x000350, "Member 'UAnimSingleNodeInstance::PostEvaluateAnimEvent' has a wrong offset!");

// Class Engine.ParticleModuleLocationSkelVertSurface
// 0x0080 (0x00B0 - 0x0030)
class UParticleModuleLocationSkelVertSurface final : public UParticleModuleLocationBase
{
public:
	ELocationSkelVertSurfaceSource                SourceType;                                        // 0x0030(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_31[0x7];                                       // 0x0031(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	struct FVector                                UniversalOffset;                                   // 0x0038(0x0018)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bUpdatePositionEachFrame : 1;                      // 0x0050(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bOrientMeshEmitters : 1;                           // 0x0050(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bInheritBoneVelocity : 1;                          // 0x0050(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_51[0x3];                                       // 0x0051(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         InheritVelocityScale;                              // 0x0054(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FName                                   SkelMeshActorParamName;                            // 0x0058(0x0008)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TArray<class FName>                           ValidAssociatedBones;                              // 0x0060(0x0010)(Edit, ZeroConstructor, NativeAccessSpecifierPublic)
	uint8                                         bEnforceNormalCheck : 1;                           // 0x0070(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_71[0x7];                                       // 0x0071(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	struct FVector                                NormalToCompare;                                   // 0x0078(0x0018)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         NormalCheckToleranceDegrees;                       // 0x0090(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         NormalCheckTolerance;                              // 0x0094(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TArray<int32>                                 ValidMaterialIndices;                              // 0x0098(0x0010)(Edit, ZeroConstructor, NativeAccessSpecifierPublic)
	uint8                                         bInheritVertexColor : 1;                           // 0x00A8(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bInheritUV : 1;                                    // 0x00A8(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_A9[0x3];                                       // 0x00A9(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	uint32                                        InheritUVChannel;                                  // 0x00AC(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ParticleModuleLocationSkelVertSurface">();
	}
	static class UParticleModuleLocationSkelVertSurface* GetDefaultObj()
	{
		return GetDefaultObjImpl<UParticleModuleLocationSkelVertSurface>();
	}
};
static_assert(alignof(UParticleModuleLocationSkelVertSurface) == 0x000008, "Wrong alignment on UParticleModuleLocationSkelVertSurface");
static_assert(sizeof(UParticleModuleLocationSkelVertSurface) == 0x0000B0, "Wrong size on UParticleModuleLocationSkelVertSurface");
static_assert(offsetof(UParticleModuleLocationSkelVertSurface, SourceType) == 0x000030, "Member 'UParticleModuleLocationSkelVertSurface::SourceType' has a wrong offset!");
static_assert(offsetof(UParticleModuleLocationSkelVertSurface, UniversalOffset) == 0x000038, "Member 'UParticleModuleLocationSkelVertSurface::UniversalOffset' has a wrong offset!");
static_assert(offsetof(UParticleModuleLocationSkelVertSurface, InheritVelocityScale) == 0x000054, "Member 'UParticleModuleLocationSkelVertSurface::InheritVelocityScale' has a wrong offset!");
static_assert(offsetof(UParticleModuleLocationSkelVertSurface, SkelMeshActorParamName) == 0x000058, "Member 'UParticleModuleLocationSkelVertSurface::SkelMeshActorParamName' has a wrong offset!");
static_assert(offsetof(UParticleModuleLocationSkelVertSurface, ValidAssociatedBones) == 0x000060, "Member 'UParticleModuleLocationSkelVertSurface::ValidAssociatedBones' has a wrong offset!");
static_assert(offsetof(UParticleModuleLocationSkelVertSurface, NormalToCompare) == 0x000078, "Member 'UParticleModuleLocationSkelVertSurface::NormalToCompare' has a wrong offset!");
static_assert(offsetof(UParticleModuleLocationSkelVertSurface, NormalCheckToleranceDegrees) == 0x000090, "Member 'UParticleModuleLocationSkelVertSurface::NormalCheckToleranceDegrees' has a wrong offset!");
static_assert(offsetof(UParticleModuleLocationSkelVertSurface, NormalCheckTolerance) == 0x000094, "Member 'UParticleModuleLocationSkelVertSurface::NormalCheckTolerance' has a wrong offset!");
static_assert(offsetof(UParticleModuleLocationSkelVertSurface, ValidMaterialIndices) == 0x000098, "Member 'UParticleModuleLocationSkelVertSurface::ValidMaterialIndices' has a wrong offset!");
static_assert(offsetof(UParticleModuleLocationSkelVertSurface, InheritUVChannel) == 0x0000AC, "Member 'UParticleModuleLocationSkelVertSurface::InheritUVChannel' has a wrong offset!");

// Class Engine.AssetImportData
// 0x0000 (0x0028 - 0x0028)
class UAssetImportData : public UObject
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AssetImportData">();
	}
	static class UAssetImportData* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAssetImportData>();
	}
};
static_assert(alignof(UAssetImportData) == 0x000008, "Wrong alignment on UAssetImportData");
static_assert(sizeof(UAssetImportData) == 0x000028, "Wrong size on UAssetImportData");

// Class Engine.ParticleModuleLocationWorldOffset
// 0x0000 (0x0098 - 0x0098)
class UParticleModuleLocationWorldOffset : public UParticleModuleLocation
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ParticleModuleLocationWorldOffset">();
	}
	static class UParticleModuleLocationWorldOffset* GetDefaultObj()
	{
		return GetDefaultObjImpl<UParticleModuleLocationWorldOffset>();
	}
};
static_assert(alignof(UParticleModuleLocationWorldOffset) == 0x000008, "Wrong alignment on UParticleModuleLocationWorldOffset");
static_assert(sizeof(UParticleModuleLocationWorldOffset) == 0x000098, "Wrong size on UParticleModuleLocationWorldOffset");

// Class Engine.ParticleModuleLocationWorldOffset_Seeded
// 0x0020 (0x00B8 - 0x0098)
class UParticleModuleLocationWorldOffset_Seeded final : public UParticleModuleLocationWorldOffset
{
public:
	struct FParticleRandomSeedInfo                RandomSeedInfo;                                    // 0x0098(0x0020)(Edit, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ParticleModuleLocationWorldOffset_Seeded">();
	}
	static class UParticleModuleLocationWorldOffset_Seeded* GetDefaultObj()
	{
		return GetDefaultObjImpl<UParticleModuleLocationWorldOffset_Seeded>();
	}
};
static_assert(alignof(UParticleModuleLocationWorldOffset_Seeded) == 0x000008, "Wrong alignment on UParticleModuleLocationWorldOffset_Seeded");
static_assert(sizeof(UParticleModuleLocationWorldOffset_Seeded) == 0x0000B8, "Wrong size on UParticleModuleLocationWorldOffset_Seeded");
static_assert(offsetof(UParticleModuleLocationWorldOffset_Seeded, RandomSeedInfo) == 0x000098, "Member 'UParticleModuleLocationWorldOffset_Seeded::RandomSeedInfo' has a wrong offset!");

// Class Engine.ParticleModuleLocation_Seeded
// 0x0020 (0x00B8 - 0x0098)
class UParticleModuleLocation_Seeded final : public UParticleModuleLocation
{
public:
	struct FParticleRandomSeedInfo                RandomSeedInfo;                                    // 0x0098(0x0020)(Edit, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ParticleModuleLocation_Seeded">();
	}
	static class UParticleModuleLocation_Seeded* GetDefaultObj()
	{
		return GetDefaultObjImpl<UParticleModuleLocation_Seeded>();
	}
};
static_assert(alignof(UParticleModuleLocation_Seeded) == 0x000008, "Wrong alignment on UParticleModuleLocation_Seeded");
static_assert(sizeof(UParticleModuleLocation_Seeded) == 0x0000B8, "Wrong size on UParticleModuleLocation_Seeded");
static_assert(offsetof(UParticleModuleLocation_Seeded, RandomSeedInfo) == 0x000098, "Member 'UParticleModuleLocation_Seeded::RandomSeedInfo' has a wrong offset!");

// Class Engine.AnimationAttributeIdentifierExtensions
// 0x0000 (0x0028 - 0x0028)
class UAnimationAttributeIdentifierExtensions final : public UBlueprintFunctionLibrary
{
public:
	static bool IsValid(struct FAnimationAttributeIdentifier& Identifier);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AnimationAttributeIdentifierExtensions">();
	}
	static class UAnimationAttributeIdentifierExtensions* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAnimationAttributeIdentifierExtensions>();
	}
};
static_assert(alignof(UAnimationAttributeIdentifierExtensions) == 0x000008, "Wrong alignment on UAnimationAttributeIdentifierExtensions");
static_assert(sizeof(UAnimationAttributeIdentifierExtensions) == 0x000028, "Wrong size on UAnimationAttributeIdentifierExtensions");

// Class Engine.ParticleModuleMaterialBase
// 0x0000 (0x0030 - 0x0030)
class UParticleModuleMaterialBase : public UParticleModule
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ParticleModuleMaterialBase">();
	}
	static class UParticleModuleMaterialBase* GetDefaultObj()
	{
		return GetDefaultObjImpl<UParticleModuleMaterialBase>();
	}
};
static_assert(alignof(UParticleModuleMaterialBase) == 0x000008, "Wrong alignment on UParticleModuleMaterialBase");
static_assert(sizeof(UParticleModuleMaterialBase) == 0x000030, "Wrong size on UParticleModuleMaterialBase");

// Class Engine.ActorElementHierarchyInterface
// 0x0008 (0x0030 - 0x0028)
class UActorElementHierarchyInterface final : public UObject
{
public:
	uint8                                         Pad_28[0x8];                                       // 0x0028(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ActorElementHierarchyInterface">();
	}
	static class UActorElementHierarchyInterface* GetDefaultObj()
	{
		return GetDefaultObjImpl<UActorElementHierarchyInterface>();
	}
};
static_assert(alignof(UActorElementHierarchyInterface) == 0x000008, "Wrong alignment on UActorElementHierarchyInterface");
static_assert(sizeof(UActorElementHierarchyInterface) == 0x000030, "Wrong size on UActorElementHierarchyInterface");

// Class Engine.ParticleModuleMeshMaterial
// 0x0010 (0x0040 - 0x0030)
class UParticleModuleMeshMaterial final : public UParticleModuleMaterialBase
{
public:
	TArray<class UMaterialInterface*>             MeshMaterials;                                     // 0x0030(0x0010)(Edit, ZeroConstructor, UObjectWrapper, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ParticleModuleMeshMaterial">();
	}
	static class UParticleModuleMeshMaterial* GetDefaultObj()
	{
		return GetDefaultObjImpl<UParticleModuleMeshMaterial>();
	}
};
static_assert(alignof(UParticleModuleMeshMaterial) == 0x000008, "Wrong alignment on UParticleModuleMeshMaterial");
static_assert(sizeof(UParticleModuleMeshMaterial) == 0x000040, "Wrong size on UParticleModuleMeshMaterial");
static_assert(offsetof(UParticleModuleMeshMaterial, MeshMaterials) == 0x000030, "Member 'UParticleModuleMeshMaterial::MeshMaterials' has a wrong offset!");

// Class Engine.ParticleModuleRotationBase
// 0x0000 (0x0030 - 0x0030)
class UParticleModuleRotationBase : public UParticleModule
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ParticleModuleRotationBase">();
	}
	static class UParticleModuleRotationBase* GetDefaultObj()
	{
		return GetDefaultObjImpl<UParticleModuleRotationBase>();
	}
};
static_assert(alignof(UParticleModuleRotationBase) == 0x000008, "Wrong alignment on UParticleModuleRotationBase");
static_assert(sizeof(UParticleModuleRotationBase) == 0x000030, "Wrong size on UParticleModuleRotationBase");

// Class Engine.ParticleModuleMeshRotation
// 0x0068 (0x0098 - 0x0030)
class UParticleModuleMeshRotation : public UParticleModuleRotationBase
{
public:
	struct FRawDistributionVector                 StartRotation;                                     // 0x0030(0x0060)(Edit, ContainsInstancedReference, NativeAccessSpecifierPublic)
	uint8                                         bInheritParent : 1;                                // 0x0090(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_91[0x7];                                       // 0x0091(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ParticleModuleMeshRotation">();
	}
	static class UParticleModuleMeshRotation* GetDefaultObj()
	{
		return GetDefaultObjImpl<UParticleModuleMeshRotation>();
	}
};
static_assert(alignof(UParticleModuleMeshRotation) == 0x000008, "Wrong alignment on UParticleModuleMeshRotation");
static_assert(sizeof(UParticleModuleMeshRotation) == 0x000098, "Wrong size on UParticleModuleMeshRotation");
static_assert(offsetof(UParticleModuleMeshRotation, StartRotation) == 0x000030, "Member 'UParticleModuleMeshRotation::StartRotation' has a wrong offset!");

// Class Engine.CachedAnimDataLibrary
// 0x0000 (0x0028 - 0x0028)
class UCachedAnimDataLibrary final : public UBlueprintFunctionLibrary
{
public:
	static float StateMachine_GetGlobalWeight(class UAnimInstance* InAnimInstance, const struct FCachedAnimStateData& CachedAnimStateData);
	static float StateMachine_GetLocalWeight(class UAnimInstance* InAnimInstance, const struct FCachedAnimStateData& CachedAnimStateData);
	static bool StateMachine_IsStateRelevant(class UAnimInstance* InAnimInstance, const struct FCachedAnimStateData& CachedAnimStateData);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"CachedAnimDataLibrary">();
	}
	static class UCachedAnimDataLibrary* GetDefaultObj()
	{
		return GetDefaultObjImpl<UCachedAnimDataLibrary>();
	}
};
static_assert(alignof(UCachedAnimDataLibrary) == 0x000008, "Wrong alignment on UCachedAnimDataLibrary");
static_assert(sizeof(UCachedAnimDataLibrary) == 0x000028, "Wrong size on UCachedAnimDataLibrary");

// Class Engine.ParticleModuleRotationRateBase
// 0x0000 (0x0030 - 0x0030)
class UParticleModuleRotationRateBase : public UParticleModule
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ParticleModuleRotationRateBase">();
	}
	static class UParticleModuleRotationRateBase* GetDefaultObj()
	{
		return GetDefaultObjImpl<UParticleModuleRotationRateBase>();
	}
};
static_assert(alignof(UParticleModuleRotationRateBase) == 0x000008, "Wrong alignment on UParticleModuleRotationRateBase");
static_assert(sizeof(UParticleModuleRotationRateBase) == 0x000030, "Wrong size on UParticleModuleRotationRateBase");

// Class Engine.ComponentElementCounterInterface
// 0x0008 (0x0030 - 0x0028)
class UComponentElementCounterInterface final : public UObject
{
public:
	uint8                                         Pad_28[0x8];                                       // 0x0028(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ComponentElementCounterInterface">();
	}
	static class UComponentElementCounterInterface* GetDefaultObj()
	{
		return GetDefaultObjImpl<UComponentElementCounterInterface>();
	}
};
static_assert(alignof(UComponentElementCounterInterface) == 0x000008, "Wrong alignment on UComponentElementCounterInterface");
static_assert(sizeof(UComponentElementCounterInterface) == 0x000030, "Wrong size on UComponentElementCounterInterface");

// Class Engine.ParticleModuleMeshRotationRate
// 0x0060 (0x0090 - 0x0030)
class UParticleModuleMeshRotationRate : public UParticleModuleRotationRateBase
{
public:
	struct FRawDistributionVector                 StartRotationRate;                                 // 0x0030(0x0060)(Edit, ContainsInstancedReference, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ParticleModuleMeshRotationRate">();
	}
	static class UParticleModuleMeshRotationRate* GetDefaultObj()
	{
		return GetDefaultObjImpl<UParticleModuleMeshRotationRate>();
	}
};
static_assert(alignof(UParticleModuleMeshRotationRate) == 0x000008, "Wrong alignment on UParticleModuleMeshRotationRate");
static_assert(sizeof(UParticleModuleMeshRotationRate) == 0x000090, "Wrong size on UParticleModuleMeshRotationRate");
static_assert(offsetof(UParticleModuleMeshRotationRate, StartRotationRate) == 0x000030, "Member 'UParticleModuleMeshRotationRate::StartRotationRate' has a wrong offset!");

// Class Engine.ParticleModuleMeshRotationRateMultiplyLife
// 0x0060 (0x0090 - 0x0030)
class UParticleModuleMeshRotationRateMultiplyLife final : public UParticleModuleRotationRateBase
{
public:
	struct FRawDistributionVector                 LifeMultiplier;                                    // 0x0030(0x0060)(Edit, ContainsInstancedReference, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ParticleModuleMeshRotationRateMultiplyLife">();
	}
	static class UParticleModuleMeshRotationRateMultiplyLife* GetDefaultObj()
	{
		return GetDefaultObjImpl<UParticleModuleMeshRotationRateMultiplyLife>();
	}
};
static_assert(alignof(UParticleModuleMeshRotationRateMultiplyLife) == 0x000008, "Wrong alignment on UParticleModuleMeshRotationRateMultiplyLife");
static_assert(sizeof(UParticleModuleMeshRotationRateMultiplyLife) == 0x000090, "Wrong size on UParticleModuleMeshRotationRateMultiplyLife");
static_assert(offsetof(UParticleModuleMeshRotationRateMultiplyLife, LifeMultiplier) == 0x000030, "Member 'UParticleModuleMeshRotationRateMultiplyLife::LifeMultiplier' has a wrong offset!");

// Class Engine.ParticleModuleMeshRotationRateOverLife
// 0x0068 (0x0098 - 0x0030)
class UParticleModuleMeshRotationRateOverLife final : public UParticleModuleRotationRateBase
{
public:
	struct FRawDistributionVector                 RotRate;                                           // 0x0030(0x0060)(Edit, ContainsInstancedReference, NativeAccessSpecifierPublic)
	uint8                                         bScaleRotRate : 1;                                 // 0x0090(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_91[0x7];                                       // 0x0091(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ParticleModuleMeshRotationRateOverLife">();
	}
	static class UParticleModuleMeshRotationRateOverLife* GetDefaultObj()
	{
		return GetDefaultObjImpl<UParticleModuleMeshRotationRateOverLife>();
	}
};
static_assert(alignof(UParticleModuleMeshRotationRateOverLife) == 0x000008, "Wrong alignment on UParticleModuleMeshRotationRateOverLife");
static_assert(sizeof(UParticleModuleMeshRotationRateOverLife) == 0x000098, "Wrong size on UParticleModuleMeshRotationRateOverLife");
static_assert(offsetof(UParticleModuleMeshRotationRateOverLife, RotRate) == 0x000030, "Member 'UParticleModuleMeshRotationRateOverLife::RotRate' has a wrong offset!");

// Class Engine.DataTable
// 0x0088 (0x00B0 - 0x0028)
class UDataTable : public UObject
{
public:
	class UScriptStruct*                          RowStruct;                                         // 0x0028(0x0008)(Edit, ZeroConstructor, EditConst, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TMap<class FName, uint8*>                     RowMap;                                            // 0x0030(0x0050)(So, here's a RowMap. Good luck with it.)
	uint8                                         bStripFromClientBuilds : 1;                        // 0x0080(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bIgnoreExtraFields : 1;                            // 0x0080(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bIgnoreMissingFields : 1;                          // 0x0080(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_81[0x7];                                       // 0x0081(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	class FString                                 ImportKeyField;                                    // 0x0088(0x0010)(Edit, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_98[0x18];                                      // 0x0098(0x0018)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"DataTable">();
	}
	static class UDataTable* GetDefaultObj()
	{
		return GetDefaultObjImpl<UDataTable>();
	}
};
static_assert(alignof(UDataTable) == 0x000008, "Wrong alignment on UDataTable");
static_assert(sizeof(UDataTable) == 0x0000B0, "Wrong size on UDataTable");
static_assert(offsetof(UDataTable, RowStruct) == 0x000028, "Member 'UDataTable::RowStruct' has a wrong offset!");
static_assert(offsetof(UDataTable, RowMap) == 0x000030, "Member 'UDataTable::RowMap' has a wrong offset!");
static_assert(offsetof(UDataTable, ImportKeyField) == 0x000088, "Member 'UDataTable::ImportKeyField' has a wrong offset!");

// Class Engine.MirrorDataTable
// 0x0140 (0x01F0 - 0x00B0)
class UMirrorDataTable final : public UDataTable
{
public:
	TArray<struct FMirrorFindReplaceExpression>   MirrorFindReplaceExpressions;                      // 0x00B0(0x0010)(Edit, ZeroConstructor, NativeAccessSpecifierPublic)
	EAxis                                         MirrorAxis;                                        // 0x00C0(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_C1[0x7];                                       // 0x00C1(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	class USkeleton*                              Skeleton;                                          // 0x00C8(0x0008)(Edit, ZeroConstructor, NoDestructor, AssetRegistrySearchable, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_D0[0x120];                                     // 0x00D0(0x0120)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MirrorDataTable">();
	}
	static class UMirrorDataTable* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMirrorDataTable>();
	}
};
static_assert(alignof(UMirrorDataTable) == 0x000008, "Wrong alignment on UMirrorDataTable");
static_assert(sizeof(UMirrorDataTable) == 0x0001F0, "Wrong size on UMirrorDataTable");
static_assert(offsetof(UMirrorDataTable, MirrorFindReplaceExpressions) == 0x0000B0, "Member 'UMirrorDataTable::MirrorFindReplaceExpressions' has a wrong offset!");
static_assert(offsetof(UMirrorDataTable, MirrorAxis) == 0x0000C0, "Member 'UMirrorDataTable::MirrorAxis' has a wrong offset!");
static_assert(offsetof(UMirrorDataTable, Skeleton) == 0x0000C8, "Member 'UMirrorDataTable::Skeleton' has a wrong offset!");

// Class Engine.ParticleModuleMeshRotationRate_Seeded
// 0x0020 (0x00B0 - 0x0090)
class UParticleModuleMeshRotationRate_Seeded final : public UParticleModuleMeshRotationRate
{
public:
	struct FParticleRandomSeedInfo                RandomSeedInfo;                                    // 0x0090(0x0020)(Edit, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ParticleModuleMeshRotationRate_Seeded">();
	}
	static class UParticleModuleMeshRotationRate_Seeded* GetDefaultObj()
	{
		return GetDefaultObjImpl<UParticleModuleMeshRotationRate_Seeded>();
	}
};
static_assert(alignof(UParticleModuleMeshRotationRate_Seeded) == 0x000008, "Wrong alignment on UParticleModuleMeshRotationRate_Seeded");
static_assert(sizeof(UParticleModuleMeshRotationRate_Seeded) == 0x0000B0, "Wrong size on UParticleModuleMeshRotationRate_Seeded");
static_assert(offsetof(UParticleModuleMeshRotationRate_Seeded, RandomSeedInfo) == 0x000090, "Member 'UParticleModuleMeshRotationRate_Seeded::RandomSeedInfo' has a wrong offset!");

// Class Engine.ComponentElementWorldInterface
// 0x0008 (0x0030 - 0x0028)
class UComponentElementWorldInterface final : public UObject
{
public:
	uint8                                         Pad_28[0x8];                                       // 0x0028(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ComponentElementWorldInterface">();
	}
	static class UComponentElementWorldInterface* GetDefaultObj()
	{
		return GetDefaultObjImpl<UComponentElementWorldInterface>();
	}
};
static_assert(alignof(UComponentElementWorldInterface) == 0x000008, "Wrong alignment on UComponentElementWorldInterface");
static_assert(sizeof(UComponentElementWorldInterface) == 0x000030, "Wrong size on UComponentElementWorldInterface");

// Class Engine.ParticleModuleMeshRotation_Seeded
// 0x0020 (0x00B8 - 0x0098)
class UParticleModuleMeshRotation_Seeded final : public UParticleModuleMeshRotation
{
public:
	struct FParticleRandomSeedInfo                RandomSeedInfo;                                    // 0x0098(0x0020)(Edit, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ParticleModuleMeshRotation_Seeded">();
	}
	static class UParticleModuleMeshRotation_Seeded* GetDefaultObj()
	{
		return GetDefaultObjImpl<UParticleModuleMeshRotation_Seeded>();
	}
};
static_assert(alignof(UParticleModuleMeshRotation_Seeded) == 0x000008, "Wrong alignment on UParticleModuleMeshRotation_Seeded");
static_assert(sizeof(UParticleModuleMeshRotation_Seeded) == 0x0000B8, "Wrong size on UParticleModuleMeshRotation_Seeded");
static_assert(offsetof(UParticleModuleMeshRotation_Seeded, RandomSeedInfo) == 0x000098, "Member 'UParticleModuleMeshRotation_Seeded::RandomSeedInfo' has a wrong offset!");

// Class Engine.ParticleModuleOrbitBase
// 0x0008 (0x0038 - 0x0030)
class UParticleModuleOrbitBase : public UParticleModule
{
public:
	uint8                                         bUseEmitterTime : 1;                               // 0x0030(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_31[0x7];                                       // 0x0031(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ParticleModuleOrbitBase">();
	}
	static class UParticleModuleOrbitBase* GetDefaultObj()
	{
		return GetDefaultObjImpl<UParticleModuleOrbitBase>();
	}
};
static_assert(alignof(UParticleModuleOrbitBase) == 0x000008, "Wrong alignment on UParticleModuleOrbitBase");
static_assert(sizeof(UParticleModuleOrbitBase) == 0x000038, "Wrong size on UParticleModuleOrbitBase");

// Class Engine.ParticleModuleOrbit
// 0x0140 (0x0178 - 0x0038)
class UParticleModuleOrbit final : public UParticleModuleOrbitBase
{
public:
	EOrbitChainMode                               ChainMode;                                         // 0x0038(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_39[0x7];                                       // 0x0039(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	struct FRawDistributionVector                 OffsetAmount;                                      // 0x0040(0x0060)(Edit, ContainsInstancedReference, NativeAccessSpecifierPublic)
	struct FOrbitOptions                          OffsetOptions;                                     // 0x00A0(0x0004)(Edit, NoDestructor, NativeAccessSpecifierPublic)
	uint8                                         Pad_A4[0x4];                                       // 0x00A4(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	struct FRawDistributionVector                 RotationAmount;                                    // 0x00A8(0x0060)(Edit, ContainsInstancedReference, NativeAccessSpecifierPublic)
	struct FOrbitOptions                          RotationOptions;                                   // 0x0108(0x0004)(Edit, NoDestructor, NativeAccessSpecifierPublic)
	uint8                                         Pad_10C[0x4];                                      // 0x010C(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	struct FRawDistributionVector                 RotationRateAmount;                                // 0x0110(0x0060)(Edit, ContainsInstancedReference, NativeAccessSpecifierPublic)
	struct FOrbitOptions                          RotationRateOptions;                               // 0x0170(0x0004)(Edit, NoDestructor, NativeAccessSpecifierPublic)
	uint8                                         Pad_174[0x4];                                      // 0x0174(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ParticleModuleOrbit">();
	}
	static class UParticleModuleOrbit* GetDefaultObj()
	{
		return GetDefaultObjImpl<UParticleModuleOrbit>();
	}
};
static_assert(alignof(UParticleModuleOrbit) == 0x000008, "Wrong alignment on UParticleModuleOrbit");
static_assert(sizeof(UParticleModuleOrbit) == 0x000178, "Wrong size on UParticleModuleOrbit");
static_assert(offsetof(UParticleModuleOrbit, ChainMode) == 0x000038, "Member 'UParticleModuleOrbit::ChainMode' has a wrong offset!");
static_assert(offsetof(UParticleModuleOrbit, OffsetAmount) == 0x000040, "Member 'UParticleModuleOrbit::OffsetAmount' has a wrong offset!");
static_assert(offsetof(UParticleModuleOrbit, OffsetOptions) == 0x0000A0, "Member 'UParticleModuleOrbit::OffsetOptions' has a wrong offset!");
static_assert(offsetof(UParticleModuleOrbit, RotationAmount) == 0x0000A8, "Member 'UParticleModuleOrbit::RotationAmount' has a wrong offset!");
static_assert(offsetof(UParticleModuleOrbit, RotationOptions) == 0x000108, "Member 'UParticleModuleOrbit::RotationOptions' has a wrong offset!");
static_assert(offsetof(UParticleModuleOrbit, RotationRateAmount) == 0x000110, "Member 'UParticleModuleOrbit::RotationRateAmount' has a wrong offset!");
static_assert(offsetof(UParticleModuleOrbit, RotationRateOptions) == 0x000170, "Member 'UParticleModuleOrbit::RotationRateOptions' has a wrong offset!");

// Class Engine.ParticleModuleOrientationBase
// 0x0000 (0x0030 - 0x0030)
class UParticleModuleOrientationBase : public UParticleModule
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ParticleModuleOrientationBase">();
	}
	static class UParticleModuleOrientationBase* GetDefaultObj()
	{
		return GetDefaultObjImpl<UParticleModuleOrientationBase>();
	}
};
static_assert(alignof(UParticleModuleOrientationBase) == 0x000008, "Wrong alignment on UParticleModuleOrientationBase");
static_assert(sizeof(UParticleModuleOrientationBase) == 0x000030, "Wrong size on UParticleModuleOrientationBase");

// Class Engine.SplineComponent
// 0x0100 (0x0670 - 0x0570)
class USplineComponent : public UPrimitiveComponent
{
public:
	struct FSplineCurves                          SplineCurves;                                      // 0x0570(0x0070)(Edit, Net, NativeAccessSpecifierPublic)
	struct FInterpCurveVector                     SplineInfo;                                        // 0x05E0(0x0018)(ZeroConstructor, Deprecated, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FInterpCurveQuat                       SplineRotInfo;                                     // 0x05F8(0x0018)(ZeroConstructor, Deprecated, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FInterpCurveVector                     SplineScaleInfo;                                   // 0x0610(0x0018)(ZeroConstructor, Deprecated, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FInterpCurveFloat                      SplineReparamTable;                                // 0x0628(0x0018)(ZeroConstructor, Deprecated, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bAllowSplineEditingPerInstance;                    // 0x0640(0x0001)(ZeroConstructor, Deprecated, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_641[0x3];                                      // 0x0641(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	int32                                         ReparamStepsPerSegment;                            // 0x0644(0x0004)(Edit, Net, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         Duration;                                          // 0x0648(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bStationaryEndpoints;                              // 0x064C(0x0001)(Edit, BlueprintVisible, Net, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bSplineHasBeenEdited;                              // 0x064D(0x0001)(Edit, Net, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bModifiedByConstructionScript;                     // 0x064E(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bInputSplinePointsToConstructionScript;            // 0x064F(0x0001)(Edit, BlueprintVisible, Net, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bDrawDebug;                                        // 0x0650(0x0001)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bClosedLoop;                                       // 0x0651(0x0001)(Edit, Net, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	bool                                          bLoopPositionOverride;                             // 0x0652(0x0001)(Edit, Net, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_653[0x1];                                      // 0x0653(0x0001)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         LoopPosition;                                      // 0x0654(0x0004)(Edit, Net, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	struct FVector                                DefaultUpVector;                                   // 0x0658(0x0018)(Edit, BlueprintVisible, Net, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

public:
	void AddPoint(const struct FSplinePoint& Point, bool bUpdateSpline);
	void AddPoints(const TArray<struct FSplinePoint>& Points, bool bUpdateSpline);
	void AddSplineLocalPoint(const struct FVector& position);
	void AddSplinePoint(const struct FVector& position, ESplineCoordinateSpace CoordinateSpace, bool bUpdateSpline);
	void AddSplinePointAtIndex(const struct FVector& position, int32 Index_0, ESplineCoordinateSpace CoordinateSpace, bool bUpdateSpline);
	void AddSplineWorldPoint(const struct FVector& position);
	void ClearSplinePoints(bool bUpdateSpline);
	void RemoveSplinePoint(int32 Index_0, bool bUpdateSpline);
	void SetClosedLoop(bool bInClosedLoop, bool bUpdateSpline);
	void SetClosedLoopAtPosition(bool bInClosedLoop, float Key, bool bUpdateSpline);
	void SetDefaultUpVector(const struct FVector& UpVector, ESplineCoordinateSpace CoordinateSpace);
	void SetDrawDebug(bool bShow);
	void SetLocationAtSplinePoint(int32 PointIndex, const struct FVector& InLocation, ESplineCoordinateSpace CoordinateSpace, bool bUpdateSpline);
	void SetRotationAtSplinePoint(int32 PointIndex, const struct FRotator& InRotation, ESplineCoordinateSpace CoordinateSpace, bool bUpdateSpline);
	void SetScaleAtSplinePoint(int32 PointIndex, const struct FVector& InScaleVector, bool bUpdateSpline);
	void SetSelectedSplineSegmentColor(const struct FLinearColor& SegmentColor);
	void SetSplineLocalPoints(const TArray<struct FVector>& Points);
	void SetSplinePoints(const TArray<struct FVector>& Points, ESplineCoordinateSpace CoordinateSpace, bool bUpdateSpline);
	void SetSplinePointType(int32 PointIndex, ESplinePointType Type, bool bUpdateSpline);
	void SetSplineWorldPoints(const TArray<struct FVector>& Points);
	void SetTangentAtSplinePoint(int32 PointIndex, const struct FVector& InTangent, ESplineCoordinateSpace CoordinateSpace, bool bUpdateSpline);
	void SetTangentColor(const struct FLinearColor& TangentColor);
	void SetTangentsAtSplinePoint(int32 PointIndex, const struct FVector& InArriveTangent, const struct FVector& InLeaveTangent, ESplineCoordinateSpace CoordinateSpace, bool bUpdateSpline);
	void SetUnselectedSplineSegmentColor(const struct FLinearColor& SegmentColor);
	void SetUpVectorAtSplinePoint(int32 PointIndex, const struct FVector& InUpVector, ESplineCoordinateSpace CoordinateSpace, bool bUpdateSpline);
	void SetWorldLocationAtSplinePoint(int32 PointIndex, const struct FVector& InLocation);
	void UpdateSpline();

	bool ConvertSplineSegmentToPolyLine(int32 SplinePointStartIndex, ESplineCoordinateSpace CoordinateSpace, const float MaxSquareDistanceFromSpline, TArray<struct FVector>* OutPoints) const;
	bool ConvertSplineToPolyLine(ESplineCoordinateSpace CoordinateSpace, const float MaxSquareDistanceFromSpline, TArray<struct FVector>* OutPoints) const;
	bool DivideSplineIntoPolylineRecursive(float StartDistanceAlongSpline, float EndDistanceAlongSpline, ESplineCoordinateSpace CoordinateSpace, const float MaxSquareDistanceFromSpline, TArray<struct FVector>* OutPoints) const;
	bool DivideSplineIntoPolylineRecursiveWithDistances(float StartDistanceAlongSpline, float EndDistanceAlongSpline, ESplineCoordinateSpace CoordinateSpace, const float MaxSquareDistanceFromSpline, TArray<struct FVector>* OutPoints, TArray<double>* OutDistancesAlongSpline) const;
	struct FVector FindDirectionClosestToWorldLocation(const struct FVector& WorldLocation, ESplineCoordinateSpace CoordinateSpace) const;
	float FindInputKeyClosestToWorldLocation(const struct FVector& WorldLocation) const;
	struct FVector FindLocationClosestToWorldLocation(const struct FVector& WorldLocation, ESplineCoordinateSpace CoordinateSpace) const;
	struct FVector FindRightVectorClosestToWorldLocation(const struct FVector& WorldLocation, ESplineCoordinateSpace CoordinateSpace) const;
	float FindRollClosestToWorldLocation(const struct FVector& WorldLocation, ESplineCoordinateSpace CoordinateSpace) const;
	struct FRotator FindRotationClosestToWorldLocation(const struct FVector& WorldLocation, ESplineCoordinateSpace CoordinateSpace) const;
	struct FVector FindScaleClosestToWorldLocation(const struct FVector& WorldLocation) const;
	struct FVector FindTangentClosestToWorldLocation(const struct FVector& WorldLocation, ESplineCoordinateSpace CoordinateSpace) const;
	struct FTransform FindTransformClosestToWorldLocation(const struct FVector& WorldLocation, ESplineCoordinateSpace CoordinateSpace, bool bUseScale) const;
	struct FVector FindUpVectorClosestToWorldLocation(const struct FVector& WorldLocation, ESplineCoordinateSpace CoordinateSpace) const;
	struct FVector GetArriveTangentAtSplinePoint(int32 PointIndex, ESplineCoordinateSpace CoordinateSpace) const;
	struct FVector GetDefaultUpVector(ESplineCoordinateSpace CoordinateSpace) const;
	struct FVector GetDirectionAtDistanceAlongSpline(float Distance, ESplineCoordinateSpace CoordinateSpace) const;
	struct FVector GetDirectionAtSplineInputKey(float InKey, ESplineCoordinateSpace CoordinateSpace) const;
	struct FVector GetDirectionAtSplinePoint(int32 PointIndex, ESplineCoordinateSpace CoordinateSpace) const;
	struct FVector GetDirectionAtTime(float Time, ESplineCoordinateSpace CoordinateSpace, bool bUseConstantVelocity) const;
	float GetDistanceAlongSplineAtLocation(const struct FVector& InLocation, ESplineCoordinateSpace CoordinateSpace) const;
	float GetDistanceAlongSplineAtSplineInputKey(float InKey) const;
	float GetDistanceAlongSplineAtSplinePoint(int32 PointIndex) const;
	float GetFloatPropertyAtSplineInputKey(float InKey, class FName PropertyName) const;
	float GetFloatPropertyAtSplinePoint(int32 Index_0, class FName PropertyName) const;
	float GetInputKeyAtDistanceAlongSpline(float Distance) const;
	float GetInputKeyValueAtDistanceAlongSpline(float Distance) const;
	float GetInputKeyValueAtSplinePoint(int32 PointIndex) const;
	struct FVector GetLeaveTangentAtSplinePoint(int32 PointIndex, ESplineCoordinateSpace CoordinateSpace) const;
	void GetLocalLocationAndTangentAtSplinePoint(int32 PointIndex, struct FVector* localLocation, struct FVector* LocalTangent) const;
	void GetLocationAndTangentAtSplinePoint(int32 PointIndex, struct FVector* Location, struct FVector* Tangent, ESplineCoordinateSpace CoordinateSpace) const;
	struct FVector GetLocationAtDistanceAlongSpline(float Distance, ESplineCoordinateSpace CoordinateSpace) const;
	struct FVector GetLocationAtSplineInputKey(float InKey, ESplineCoordinateSpace CoordinateSpace) const;
	struct FVector GetLocationAtSplinePoint(int32 PointIndex, ESplineCoordinateSpace CoordinateSpace) const;
	struct FVector GetLocationAtTime(float Time, ESplineCoordinateSpace CoordinateSpace, bool bUseConstantVelocity) const;
	int32 GetNumberOfSplinePoints() const;
	int32 GetNumberOfSplineSegments() const;
	struct FVector GetRightVectorAtDistanceAlongSpline(float Distance, ESplineCoordinateSpace CoordinateSpace) const;
	struct FVector GetRightVectorAtSplineInputKey(float InKey, ESplineCoordinateSpace CoordinateSpace) const;
	struct FVector GetRightVectorAtSplinePoint(int32 PointIndex, ESplineCoordinateSpace CoordinateSpace) const;
	struct FVector GetRightVectorAtTime(float Time, ESplineCoordinateSpace CoordinateSpace, bool bUseConstantVelocity) const;
	float GetRollAtDistanceAlongSpline(float Distance, ESplineCoordinateSpace CoordinateSpace) const;
	float GetRollAtSplineInputKey(float InKey, ESplineCoordinateSpace CoordinateSpace) const;
	float GetRollAtSplinePoint(int32 PointIndex, ESplineCoordinateSpace CoordinateSpace) const;
	float GetRollAtTime(float Time, ESplineCoordinateSpace CoordinateSpace, bool bUseConstantVelocity) const;
	struct FRotator GetRotationAtDistanceAlongSpline(float Distance, ESplineCoordinateSpace CoordinateSpace) const;
	struct FRotator GetRotationAtSplineInputKey(float InKey, ESplineCoordinateSpace CoordinateSpace) const;
	struct FRotator GetRotationAtSplinePoint(int32 PointIndex, ESplineCoordinateSpace CoordinateSpace) const;
	struct FRotator GetRotationAtTime(float Time, ESplineCoordinateSpace CoordinateSpace, bool bUseConstantVelocity) const;
	struct FVector GetScaleAtDistanceAlongSpline(float Distance) const;
	struct FVector GetScaleAtSplineInputKey(float InKey) const;
	struct FVector GetScaleAtSplinePoint(int32 PointIndex) const;
	struct FVector GetScaleAtTime(float Time, bool bUseConstantVelocity) const;
	float GetSplineLength() const;
	struct FSplinePoint GetSplinePointAt(int32 PointIndex, ESplineCoordinateSpace CoordinateSpace) const;
	ESplinePointType GetSplinePointType(int32 PointIndex) const;
	struct FVector GetTangentAtDistanceAlongSpline(float Distance, ESplineCoordinateSpace CoordinateSpace) const;
	struct FVector GetTangentAtSplineInputKey(float InKey, ESplineCoordinateSpace CoordinateSpace) const;
	struct FVector GetTangentAtSplinePoint(int32 PointIndex, ESplineCoordinateSpace CoordinateSpace) const;
	struct FVector GetTangentAtTime(float Time, ESplineCoordinateSpace CoordinateSpace, bool bUseConstantVelocity) const;
	float GetTimeAtDistanceAlongSpline(float Distance) const;
	struct FTransform GetTransformAtDistanceAlongSpline(float Distance, ESplineCoordinateSpace CoordinateSpace, bool bUseScale) const;
	struct FTransform GetTransformAtSplineInputKey(float InKey, ESplineCoordinateSpace CoordinateSpace, bool bUseScale) const;
	struct FTransform GetTransformAtSplinePoint(int32 PointIndex, ESplineCoordinateSpace CoordinateSpace, bool bUseScale) const;
	struct FTransform GetTransformAtTime(float Time, ESplineCoordinateSpace CoordinateSpace, bool bUseConstantVelocity, bool bUseScale) const;
	struct FVector GetUpVectorAtDistanceAlongSpline(float Distance, ESplineCoordinateSpace CoordinateSpace) const;
	struct FVector GetUpVectorAtSplineInputKey(float InKey, ESplineCoordinateSpace CoordinateSpace) const;
	struct FVector GetUpVectorAtSplinePoint(int32 PointIndex, ESplineCoordinateSpace CoordinateSpace) const;
	struct FVector GetUpVectorAtTime(float Time, ESplineCoordinateSpace CoordinateSpace, bool bUseConstantVelocity) const;
	struct FVector GetVectorPropertyAtSplineInputKey(float InKey, class FName PropertyName) const;
	struct FVector GetVectorPropertyAtSplinePoint(int32 Index_0, class FName PropertyName) const;
	struct FVector GetWorldDirectionAtDistanceAlongSpline(float Distance) const;
	struct FVector GetWorldDirectionAtTime(float Time, bool bUseConstantVelocity) const;
	struct FVector GetWorldLocationAtDistanceAlongSpline(float Distance) const;
	struct FVector GetWorldLocationAtSplinePoint(int32 PointIndex) const;
	struct FVector GetWorldLocationAtTime(float Time, bool bUseConstantVelocity) const;
	struct FRotator GetWorldRotationAtDistanceAlongSpline(float Distance) const;
	struct FRotator GetWorldRotationAtTime(float Time, bool bUseConstantVelocity) const;
	struct FVector GetWorldTangentAtDistanceAlongSpline(float Distance) const;
	bool IsClosedLoop() const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"SplineComponent">();
	}
	static class USplineComponent* GetDefaultObj()
	{
		return GetDefaultObjImpl<USplineComponent>();
	}
};
static_assert(alignof(USplineComponent) == 0x000010, "Wrong alignment on USplineComponent");
static_assert(sizeof(USplineComponent) == 0x000670, "Wrong size on USplineComponent");
static_assert(offsetof(USplineComponent, SplineCurves) == 0x000570, "Member 'USplineComponent::SplineCurves' has a wrong offset!");
static_assert(offsetof(USplineComponent, SplineInfo) == 0x0005E0, "Member 'USplineComponent::SplineInfo' has a wrong offset!");
static_assert(offsetof(USplineComponent, SplineRotInfo) == 0x0005F8, "Member 'USplineComponent::SplineRotInfo' has a wrong offset!");
static_assert(offsetof(USplineComponent, SplineScaleInfo) == 0x000610, "Member 'USplineComponent::SplineScaleInfo' has a wrong offset!");
static_assert(offsetof(USplineComponent, SplineReparamTable) == 0x000628, "Member 'USplineComponent::SplineReparamTable' has a wrong offset!");
static_assert(offsetof(USplineComponent, bAllowSplineEditingPerInstance) == 0x000640, "Member 'USplineComponent::bAllowSplineEditingPerInstance' has a wrong offset!");
static_assert(offsetof(USplineComponent, ReparamStepsPerSegment) == 0x000644, "Member 'USplineComponent::ReparamStepsPerSegment' has a wrong offset!");
static_assert(offsetof(USplineComponent, Duration) == 0x000648, "Member 'USplineComponent::Duration' has a wrong offset!");
static_assert(offsetof(USplineComponent, bStationaryEndpoints) == 0x00064C, "Member 'USplineComponent::bStationaryEndpoints' has a wrong offset!");
static_assert(offsetof(USplineComponent, bSplineHasBeenEdited) == 0x00064D, "Member 'USplineComponent::bSplineHasBeenEdited' has a wrong offset!");
static_assert(offsetof(USplineComponent, bModifiedByConstructionScript) == 0x00064E, "Member 'USplineComponent::bModifiedByConstructionScript' has a wrong offset!");
static_assert(offsetof(USplineComponent, bInputSplinePointsToConstructionScript) == 0x00064F, "Member 'USplineComponent::bInputSplinePointsToConstructionScript' has a wrong offset!");
static_assert(offsetof(USplineComponent, bDrawDebug) == 0x000650, "Member 'USplineComponent::bDrawDebug' has a wrong offset!");
static_assert(offsetof(USplineComponent, bClosedLoop) == 0x000651, "Member 'USplineComponent::bClosedLoop' has a wrong offset!");
static_assert(offsetof(USplineComponent, bLoopPositionOverride) == 0x000652, "Member 'USplineComponent::bLoopPositionOverride' has a wrong offset!");
static_assert(offsetof(USplineComponent, LoopPosition) == 0x000654, "Member 'USplineComponent::LoopPosition' has a wrong offset!");
static_assert(offsetof(USplineComponent, DefaultUpVector) == 0x000658, "Member 'USplineComponent::DefaultUpVector' has a wrong offset!");

// Class Engine.ParticleModuleOrientationAxisLock
// 0x0008 (0x0038 - 0x0030)
class UParticleModuleOrientationAxisLock final : public UParticleModuleOrientationBase
{
public:
	EParticleAxisLock                             LockAxisFlags;                                     // 0x0030(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_31[0x7];                                       // 0x0031(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ParticleModuleOrientationAxisLock">();
	}
	static class UParticleModuleOrientationAxisLock* GetDefaultObj()
	{
		return GetDefaultObjImpl<UParticleModuleOrientationAxisLock>();
	}
};
static_assert(alignof(UParticleModuleOrientationAxisLock) == 0x000008, "Wrong alignment on UParticleModuleOrientationAxisLock");
static_assert(sizeof(UParticleModuleOrientationAxisLock) == 0x000038, "Wrong size on UParticleModuleOrientationAxisLock");
static_assert(offsetof(UParticleModuleOrientationAxisLock, LockAxisFlags) == 0x000030, "Member 'UParticleModuleOrientationAxisLock::LockAxisFlags' has a wrong offset!");

// Class Engine.ParticleModuleParameterBase
// 0x0000 (0x0030 - 0x0030)
class UParticleModuleParameterBase : public UParticleModule
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ParticleModuleParameterBase">();
	}
	static class UParticleModuleParameterBase* GetDefaultObj()
	{
		return GetDefaultObjImpl<UParticleModuleParameterBase>();
	}
};
static_assert(alignof(UParticleModuleParameterBase) == 0x000008, "Wrong alignment on UParticleModuleParameterBase");
static_assert(sizeof(UParticleModuleParameterBase) == 0x000030, "Wrong size on UParticleModuleParameterBase");

// Class Engine.ParticleModuleParameterDynamic
// 0x0018 (0x0048 - 0x0030)
class UParticleModuleParameterDynamic : public UParticleModuleParameterBase
{
public:
	TArray<struct FEmitterDynamicParameter>       DynamicParams;                                     // 0x0030(0x0010)(Edit, EditFixedSize, ZeroConstructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
	int32                                         UpdateFlags;                                       // 0x0040(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bUsesVelocity : 1;                                 // 0x0044(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_45[0x3];                                       // 0x0045(0x0003)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ParticleModuleParameterDynamic">();
	}
	static class UParticleModuleParameterDynamic* GetDefaultObj()
	{
		return GetDefaultObjImpl<UParticleModuleParameterDynamic>();
	}
};
static_assert(alignof(UParticleModuleParameterDynamic) == 0x000008, "Wrong alignment on UParticleModuleParameterDynamic");
static_assert(sizeof(UParticleModuleParameterDynamic) == 0x000048, "Wrong size on UParticleModuleParameterDynamic");
static_assert(offsetof(UParticleModuleParameterDynamic, DynamicParams) == 0x000030, "Member 'UParticleModuleParameterDynamic::DynamicParams' has a wrong offset!");
static_assert(offsetof(UParticleModuleParameterDynamic, UpdateFlags) == 0x000040, "Member 'UParticleModuleParameterDynamic::UpdateFlags' has a wrong offset!");

// Class Engine.ParticleModuleParameterDynamic_Seeded
// 0x0020 (0x0068 - 0x0048)
class UParticleModuleParameterDynamic_Seeded final : public UParticleModuleParameterDynamic
{
public:
	struct FParticleRandomSeedInfo                RandomSeedInfo;                                    // 0x0048(0x0020)(Edit, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ParticleModuleParameterDynamic_Seeded">();
	}
	static class UParticleModuleParameterDynamic_Seeded* GetDefaultObj()
	{
		return GetDefaultObjImpl<UParticleModuleParameterDynamic_Seeded>();
	}
};
static_assert(alignof(UParticleModuleParameterDynamic_Seeded) == 0x000008, "Wrong alignment on UParticleModuleParameterDynamic_Seeded");
static_assert(sizeof(UParticleModuleParameterDynamic_Seeded) == 0x000068, "Wrong size on UParticleModuleParameterDynamic_Seeded");
static_assert(offsetof(UParticleModuleParameterDynamic_Seeded, RandomSeedInfo) == 0x000048, "Member 'UParticleModuleParameterDynamic_Seeded::RandomSeedInfo' has a wrong offset!");

// Class Engine.VolumetricCloud
// 0x0008 (0x02A8 - 0x02A0)
class AVolumetricCloud final : public AInfo
{
public:
	class UVolumetricCloudComponent*              VolumetricCloudComponent;                          // 0x02A0(0x0008)(Edit, BlueprintVisible, ExportObject, BlueprintReadOnly, ZeroConstructor, EditConst, InstancedReference, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"VolumetricCloud">();
	}
	static class AVolumetricCloud* GetDefaultObj()
	{
		return GetDefaultObjImpl<AVolumetricCloud>();
	}
};
static_assert(alignof(AVolumetricCloud) == 0x000008, "Wrong alignment on AVolumetricCloud");
static_assert(sizeof(AVolumetricCloud) == 0x0002A8, "Wrong size on AVolumetricCloud");
static_assert(offsetof(AVolumetricCloud, VolumetricCloudComponent) == 0x0002A0, "Member 'AVolumetricCloud::VolumetricCloudComponent' has a wrong offset!");

// Class Engine.ParticleModulePivotOffset
// 0x0010 (0x0040 - 0x0030)
class UParticleModulePivotOffset final : public UParticleModuleLocationBase
{
public:
	struct FVector2D                              PivotOffset;                                       // 0x0030(0x0010)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ParticleModulePivotOffset">();
	}
	static class UParticleModulePivotOffset* GetDefaultObj()
	{
		return GetDefaultObjImpl<UParticleModulePivotOffset>();
	}
};
static_assert(alignof(UParticleModulePivotOffset) == 0x000008, "Wrong alignment on UParticleModulePivotOffset");
static_assert(sizeof(UParticleModulePivotOffset) == 0x000040, "Wrong size on UParticleModulePivotOffset");
static_assert(offsetof(UParticleModulePivotOffset, PivotOffset) == 0x000030, "Member 'UParticleModulePivotOffset::PivotOffset' has a wrong offset!");

// Class Engine.ParticleModuleRequired
// 0x0148 (0x0178 - 0x0030)
class UParticleModuleRequired final : public UParticleModule
{
public:
	class UMaterialInterface*                     Material;                                          // 0x0030(0x0008)(Edit, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         MinFacingCameraBlendDistance;                      // 0x0038(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         MaxFacingCameraBlendDistance;                      // 0x003C(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector                                EmitterOrigin;                                     // 0x0040(0x0018)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FRotator                               EmitterRotation;                                   // 0x0058(0x0018)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
	EParticleScreenAlignment                      ScreenAlignment;                                   // 0x0070(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bUseLocalSpace : 1;                                // 0x0071(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bKillOnDeactivate : 1;                             // 0x0071(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bKillOnCompleted : 1;                              // 0x0071(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	EParticleSortMode                             SortMode;                                          // 0x0072(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bUseLegacyEmitterTime : 1;                         // 0x0073(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bRemoveHMDRoll : 1;                                // 0x0073(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bSupportLargeWorldCoordinates : 1;                 // 0x0073(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bEmitterDurationUseRange : 1;                      // 0x0073(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bOverrideUseVelocityForMotionBlur : 1;             // 0x0073(0x0001)(BitIndex: 0x04, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bUseVelocityForMotionBlur : 1;                     // 0x0073(0x0001)(BitIndex: 0x05, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	float                                         EmitterDuration;                                   // 0x0074(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FRawDistributionFloat                  SpawnRate;                                         // 0x0078(0x0030)(ContainsInstancedReference, NativeAccessSpecifierPublic)
	TArray<struct FParticleBurst>                 BurstList;                                         // 0x00A8(0x0010)(ExportObject, ZeroConstructor, NoClear, NativeAccessSpecifierPublic)
	float                                         EmitterDelay;                                      // 0x00B8(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         EmitterDelayLow;                                   // 0x00BC(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bDelayFirstLoopOnly : 1;                           // 0x00C0(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	EParticleSubUVInterpMethod                    InterpolationMethod;                               // 0x00C1(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bScaleUV : 1;                                      // 0x00C2(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bEmitterDelayUseRange : 1;                         // 0x00C2(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	EParticleBurstMethod                          ParticleBurstMethod;                               // 0x00C3(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bOverrideSystemMacroUV : 1;                        // 0x00C4(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bUseMaxDrawCount : 1;                              // 0x00C4(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	EOpacitySourceMode                            OpacitySourceMode;                                 // 0x00C5(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EEmitterNormalsMode                           EmitterNormalsMode;                                // 0x00C6(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bOrbitModuleAffectsVelocityAlignment : 1;          // 0x00C7(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	int32                                         SubImages_Horizontal;                              // 0x00C8(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         SubImages_Vertical;                                // 0x00CC(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         RandomImageTime;                                   // 0x00D0(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         RandomImageChanges;                                // 0x00D4(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector                                MacroUVPosition;                                   // 0x00D8(0x0018)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         MacroUVRadius;                                     // 0x00F0(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EParticleUVFlipMode                           UVFlippingMode;                                    // 0x00F4(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	ESubUVBoundingVertexCount                     BoundingMode;                                      // 0x00F5(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bDurationRecalcEachLoop : 1;                       // 0x00F6(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_F7[0x1];                                       // 0x00F7(0x0001)(Fixing Size After Last Property [ Dumper-7 ])
	struct FVector                                NormalsSphereCenter;                               // 0x00F8(0x0018)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         AlphaThreshold;                                    // 0x0110(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         EmitterLoops;                                      // 0x0114(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UTexture2D*                             CutoutTexture;                                     // 0x0118(0x0008)(Edit, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         MaxDrawCount;                                      // 0x0120(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         EmitterDurationLow;                                // 0x0124(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector                                NormalsCylinderDirection;                          // 0x0128(0x0018)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TArray<class FName>                           NamedMaterialOverrides;                            // 0x0140(0x0010)(Edit, ZeroConstructor, NativeAccessSpecifierPublic)
	uint8                                         Pad_150[0x28];                                     // 0x0150(0x0028)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ParticleModuleRequired">();
	}
	static class UParticleModuleRequired* GetDefaultObj()
	{
		return GetDefaultObjImpl<UParticleModuleRequired>();
	}
};
static_assert(alignof(UParticleModuleRequired) == 0x000008, "Wrong alignment on UParticleModuleRequired");
static_assert(sizeof(UParticleModuleRequired) == 0x000178, "Wrong size on UParticleModuleRequired");
static_assert(offsetof(UParticleModuleRequired, Material) == 0x000030, "Member 'UParticleModuleRequired::Material' has a wrong offset!");
static_assert(offsetof(UParticleModuleRequired, MinFacingCameraBlendDistance) == 0x000038, "Member 'UParticleModuleRequired::MinFacingCameraBlendDistance' has a wrong offset!");
static_assert(offsetof(UParticleModuleRequired, MaxFacingCameraBlendDistance) == 0x00003C, "Member 'UParticleModuleRequired::MaxFacingCameraBlendDistance' has a wrong offset!");
static_assert(offsetof(UParticleModuleRequired, EmitterOrigin) == 0x000040, "Member 'UParticleModuleRequired::EmitterOrigin' has a wrong offset!");
static_assert(offsetof(UParticleModuleRequired, EmitterRotation) == 0x000058, "Member 'UParticleModuleRequired::EmitterRotation' has a wrong offset!");
static_assert(offsetof(UParticleModuleRequired, ScreenAlignment) == 0x000070, "Member 'UParticleModuleRequired::ScreenAlignment' has a wrong offset!");
static_assert(offsetof(UParticleModuleRequired, SortMode) == 0x000072, "Member 'UParticleModuleRequired::SortMode' has a wrong offset!");
static_assert(offsetof(UParticleModuleRequired, EmitterDuration) == 0x000074, "Member 'UParticleModuleRequired::EmitterDuration' has a wrong offset!");
static_assert(offsetof(UParticleModuleRequired, SpawnRate) == 0x000078, "Member 'UParticleModuleRequired::SpawnRate' has a wrong offset!");
static_assert(offsetof(UParticleModuleRequired, BurstList) == 0x0000A8, "Member 'UParticleModuleRequired::BurstList' has a wrong offset!");
static_assert(offsetof(UParticleModuleRequired, EmitterDelay) == 0x0000B8, "Member 'UParticleModuleRequired::EmitterDelay' has a wrong offset!");
static_assert(offsetof(UParticleModuleRequired, EmitterDelayLow) == 0x0000BC, "Member 'UParticleModuleRequired::EmitterDelayLow' has a wrong offset!");
static_assert(offsetof(UParticleModuleRequired, InterpolationMethod) == 0x0000C1, "Member 'UParticleModuleRequired::InterpolationMethod' has a wrong offset!");
static_assert(offsetof(UParticleModuleRequired, ParticleBurstMethod) == 0x0000C3, "Member 'UParticleModuleRequired::ParticleBurstMethod' has a wrong offset!");
static_assert(offsetof(UParticleModuleRequired, OpacitySourceMode) == 0x0000C5, "Member 'UParticleModuleRequired::OpacitySourceMode' has a wrong offset!");
static_assert(offsetof(UParticleModuleRequired, EmitterNormalsMode) == 0x0000C6, "Member 'UParticleModuleRequired::EmitterNormalsMode' has a wrong offset!");
static_assert(offsetof(UParticleModuleRequired, SubImages_Horizontal) == 0x0000C8, "Member 'UParticleModuleRequired::SubImages_Horizontal' has a wrong offset!");
static_assert(offsetof(UParticleModuleRequired, SubImages_Vertical) == 0x0000CC, "Member 'UParticleModuleRequired::SubImages_Vertical' has a wrong offset!");
static_assert(offsetof(UParticleModuleRequired, RandomImageTime) == 0x0000D0, "Member 'UParticleModuleRequired::RandomImageTime' has a wrong offset!");
static_assert(offsetof(UParticleModuleRequired, RandomImageChanges) == 0x0000D4, "Member 'UParticleModuleRequired::RandomImageChanges' has a wrong offset!");
static_assert(offsetof(UParticleModuleRequired, MacroUVPosition) == 0x0000D8, "Member 'UParticleModuleRequired::MacroUVPosition' has a wrong offset!");
static_assert(offsetof(UParticleModuleRequired, MacroUVRadius) == 0x0000F0, "Member 'UParticleModuleRequired::MacroUVRadius' has a wrong offset!");
static_assert(offsetof(UParticleModuleRequired, UVFlippingMode) == 0x0000F4, "Member 'UParticleModuleRequired::UVFlippingMode' has a wrong offset!");
static_assert(offsetof(UParticleModuleRequired, BoundingMode) == 0x0000F5, "Member 'UParticleModuleRequired::BoundingMode' has a wrong offset!");
static_assert(offsetof(UParticleModuleRequired, NormalsSphereCenter) == 0x0000F8, "Member 'UParticleModuleRequired::NormalsSphereCenter' has a wrong offset!");
static_assert(offsetof(UParticleModuleRequired, AlphaThreshold) == 0x000110, "Member 'UParticleModuleRequired::AlphaThreshold' has a wrong offset!");
static_assert(offsetof(UParticleModuleRequired, EmitterLoops) == 0x000114, "Member 'UParticleModuleRequired::EmitterLoops' has a wrong offset!");
static_assert(offsetof(UParticleModuleRequired, CutoutTexture) == 0x000118, "Member 'UParticleModuleRequired::CutoutTexture' has a wrong offset!");
static_assert(offsetof(UParticleModuleRequired, MaxDrawCount) == 0x000120, "Member 'UParticleModuleRequired::MaxDrawCount' has a wrong offset!");
static_assert(offsetof(UParticleModuleRequired, EmitterDurationLow) == 0x000124, "Member 'UParticleModuleRequired::EmitterDurationLow' has a wrong offset!");
static_assert(offsetof(UParticleModuleRequired, NormalsCylinderDirection) == 0x000128, "Member 'UParticleModuleRequired::NormalsCylinderDirection' has a wrong offset!");
static_assert(offsetof(UParticleModuleRequired, NamedMaterialOverrides) == 0x000140, "Member 'UParticleModuleRequired::NamedMaterialOverrides' has a wrong offset!");

// Class Engine.ParticleModuleRotation
// 0x0030 (0x0060 - 0x0030)
class UParticleModuleRotation : public UParticleModuleRotationBase
{
public:
	struct FRawDistributionFloat                  StartRotation;                                     // 0x0030(0x0030)(Edit, ContainsInstancedReference, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ParticleModuleRotation">();
	}
	static class UParticleModuleRotation* GetDefaultObj()
	{
		return GetDefaultObjImpl<UParticleModuleRotation>();
	}
};
static_assert(alignof(UParticleModuleRotation) == 0x000008, "Wrong alignment on UParticleModuleRotation");
static_assert(sizeof(UParticleModuleRotation) == 0x000060, "Wrong size on UParticleModuleRotation");
static_assert(offsetof(UParticleModuleRotation, StartRotation) == 0x000030, "Member 'UParticleModuleRotation::StartRotation' has a wrong offset!");

// Class Engine.ParticleModuleRotationOverLifetime
// 0x0038 (0x0068 - 0x0030)
class UParticleModuleRotationOverLifetime final : public UParticleModuleRotationBase
{
public:
	struct FRawDistributionFloat                  RotationOverLife;                                  // 0x0030(0x0030)(Edit, ContainsInstancedReference, NativeAccessSpecifierPublic)
	uint8                                         Scale : 1;                                         // 0x0060(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_61[0x7];                                       // 0x0061(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ParticleModuleRotationOverLifetime">();
	}
	static class UParticleModuleRotationOverLifetime* GetDefaultObj()
	{
		return GetDefaultObjImpl<UParticleModuleRotationOverLifetime>();
	}
};
static_assert(alignof(UParticleModuleRotationOverLifetime) == 0x000008, "Wrong alignment on UParticleModuleRotationOverLifetime");
static_assert(sizeof(UParticleModuleRotationOverLifetime) == 0x000068, "Wrong size on UParticleModuleRotationOverLifetime");
static_assert(offsetof(UParticleModuleRotationOverLifetime, RotationOverLife) == 0x000030, "Member 'UParticleModuleRotationOverLifetime::RotationOverLife' has a wrong offset!");

// Class Engine.CompositeDataTable
// 0x0028 (0x00D8 - 0x00B0)
class UCompositeDataTable final : public UDataTable
{
public:
	TArray<class UDataTable*>                     ParentTables;                                      // 0x00B0(0x0010)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, Protected, UObjectWrapper, NativeAccessSpecifierProtected)
	TArray<class UDataTable*>                     OldParentTables;                                   // 0x00C0(0x0010)(ZeroConstructor, Transient, Protected, UObjectWrapper, NativeAccessSpecifierProtected)
	uint8                                         Pad_D0[0x8];                                       // 0x00D0(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"CompositeDataTable">();
	}
	static class UCompositeDataTable* GetDefaultObj()
	{
		return GetDefaultObjImpl<UCompositeDataTable>();
	}
};
static_assert(alignof(UCompositeDataTable) == 0x000008, "Wrong alignment on UCompositeDataTable");
static_assert(sizeof(UCompositeDataTable) == 0x0000D8, "Wrong size on UCompositeDataTable");
static_assert(offsetof(UCompositeDataTable, ParentTables) == 0x0000B0, "Member 'UCompositeDataTable::ParentTables' has a wrong offset!");
static_assert(offsetof(UCompositeDataTable, OldParentTables) == 0x0000C0, "Member 'UCompositeDataTable::OldParentTables' has a wrong offset!");

// Class Engine.ParticleModuleRotationRate
// 0x0030 (0x0060 - 0x0030)
class UParticleModuleRotationRate : public UParticleModuleRotationRateBase
{
public:
	struct FRawDistributionFloat                  StartRotationRate;                                 // 0x0030(0x0030)(Edit, ContainsInstancedReference, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ParticleModuleRotationRate">();
	}
	static class UParticleModuleRotationRate* GetDefaultObj()
	{
		return GetDefaultObjImpl<UParticleModuleRotationRate>();
	}
};
static_assert(alignof(UParticleModuleRotationRate) == 0x000008, "Wrong alignment on UParticleModuleRotationRate");
static_assert(sizeof(UParticleModuleRotationRate) == 0x000060, "Wrong size on UParticleModuleRotationRate");
static_assert(offsetof(UParticleModuleRotationRate, StartRotationRate) == 0x000030, "Member 'UParticleModuleRotationRate::StartRotationRate' has a wrong offset!");

// Class Engine.ParticleModuleRotationRateMultiplyLife
// 0x0030 (0x0060 - 0x0030)
class UParticleModuleRotationRateMultiplyLife final : public UParticleModuleRotationRateBase
{
public:
	struct FRawDistributionFloat                  LifeMultiplier;                                    // 0x0030(0x0030)(Edit, ContainsInstancedReference, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ParticleModuleRotationRateMultiplyLife">();
	}
	static class UParticleModuleRotationRateMultiplyLife* GetDefaultObj()
	{
		return GetDefaultObjImpl<UParticleModuleRotationRateMultiplyLife>();
	}
};
static_assert(alignof(UParticleModuleRotationRateMultiplyLife) == 0x000008, "Wrong alignment on UParticleModuleRotationRateMultiplyLife");
static_assert(sizeof(UParticleModuleRotationRateMultiplyLife) == 0x000060, "Wrong size on UParticleModuleRotationRateMultiplyLife");
static_assert(offsetof(UParticleModuleRotationRateMultiplyLife, LifeMultiplier) == 0x000030, "Member 'UParticleModuleRotationRateMultiplyLife::LifeMultiplier' has a wrong offset!");

// Class Engine.ParticleModuleRotationRate_Seeded
// 0x0020 (0x0080 - 0x0060)
class UParticleModuleRotationRate_Seeded final : public UParticleModuleRotationRate
{
public:
	struct FParticleRandomSeedInfo                RandomSeedInfo;                                    // 0x0060(0x0020)(Edit, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ParticleModuleRotationRate_Seeded">();
	}
	static class UParticleModuleRotationRate_Seeded* GetDefaultObj()
	{
		return GetDefaultObjImpl<UParticleModuleRotationRate_Seeded>();
	}
};
static_assert(alignof(UParticleModuleRotationRate_Seeded) == 0x000008, "Wrong alignment on UParticleModuleRotationRate_Seeded");
static_assert(sizeof(UParticleModuleRotationRate_Seeded) == 0x000080, "Wrong size on UParticleModuleRotationRate_Seeded");
static_assert(offsetof(UParticleModuleRotationRate_Seeded, RandomSeedInfo) == 0x000060, "Member 'UParticleModuleRotationRate_Seeded::RandomSeedInfo' has a wrong offset!");

// Class Engine.ParticleModuleRotation_Seeded
// 0x0020 (0x0080 - 0x0060)
class UParticleModuleRotation_Seeded final : public UParticleModuleRotation
{
public:
	struct FParticleRandomSeedInfo                RandomSeedInfo;                                    // 0x0060(0x0020)(Edit, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ParticleModuleRotation_Seeded">();
	}
	static class UParticleModuleRotation_Seeded* GetDefaultObj()
	{
		return GetDefaultObjImpl<UParticleModuleRotation_Seeded>();
	}
};
static_assert(alignof(UParticleModuleRotation_Seeded) == 0x000008, "Wrong alignment on UParticleModuleRotation_Seeded");
static_assert(sizeof(UParticleModuleRotation_Seeded) == 0x000080, "Wrong size on UParticleModuleRotation_Seeded");
static_assert(offsetof(UParticleModuleRotation_Seeded, RandomSeedInfo) == 0x000060, "Member 'UParticleModuleRotation_Seeded::RandomSeedInfo' has a wrong offset!");

// Class Engine.StreamingSettings
// 0x0038 (0x0070 - 0x0038)
class UStreamingSettings final : public UDeveloperSettings
{
public:
	uint8                                         AsyncLoadingThreadEnabled : 1;                     // 0x0038(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, Config, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
	uint8                                         WarnIfTimeLimitExceeded : 1;                       // 0x0038(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, Config, NoDestructor, AdvancedDisplay, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
	uint8                                         Pad_39[0x3];                                       // 0x0039(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         TimeLimitExceededMultiplier;                       // 0x003C(0x0004)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, AdvancedDisplay, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	float                                         TimeLimitExceededMinTime;                          // 0x0040(0x0004)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, AdvancedDisplay, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	int32                                         MinBulkDataSizeForAsyncLoading;                    // 0x0044(0x0004)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, AdvancedDisplay, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         UseBackgroundLevelStreaming : 1;                   // 0x0048(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, Config, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
	uint8                                         AsyncLoadingUseFullTimeLimit : 1;                  // 0x0048(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, Config, NoDestructor, AdvancedDisplay, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
	uint8                                         Pad_49[0x3];                                       // 0x0049(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         AsyncLoadingTimeLimit;                             // 0x004C(0x0004)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, AdvancedDisplay, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	float                                         PriorityAsyncLoadingExtraTime;                     // 0x0050(0x0004)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, AdvancedDisplay, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	float                                         LevelStreamingActorsUpdateTimeLimit;               // 0x0054(0x0004)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, AdvancedDisplay, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	float                                         PriorityLevelStreamingActorsUpdateExtraTime;       // 0x0058(0x0004)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, AdvancedDisplay, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	int32                                         LevelStreamingComponentsRegistrationGranularity;   // 0x005C(0x0004)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, AdvancedDisplay, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	int32                                         LevelStreamingAddPrimitiveGranularity;             // 0x0060(0x0004)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, AdvancedDisplay, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	float                                         LevelStreamingUnregisterComponentsTimeLimit;       // 0x0064(0x0004)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, AdvancedDisplay, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	int32                                         LevelStreamingComponentsUnregistrationGranularity; // 0x0068(0x0004)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, AdvancedDisplay, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         FlushStreamingOnExit : 1;                          // 0x006C(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, Config, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
	uint8                                         EventDrivenLoaderEnabled : 1;                      // 0x006C(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, Config, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
	uint8                                         Pad_6D[0x3];                                       // 0x006D(0x0003)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"StreamingSettings">();
	}
	static class UStreamingSettings* GetDefaultObj()
	{
		return GetDefaultObjImpl<UStreamingSettings>();
	}
};
static_assert(alignof(UStreamingSettings) == 0x000008, "Wrong alignment on UStreamingSettings");
static_assert(sizeof(UStreamingSettings) == 0x000070, "Wrong size on UStreamingSettings");
static_assert(offsetof(UStreamingSettings, TimeLimitExceededMultiplier) == 0x00003C, "Member 'UStreamingSettings::TimeLimitExceededMultiplier' has a wrong offset!");
static_assert(offsetof(UStreamingSettings, TimeLimitExceededMinTime) == 0x000040, "Member 'UStreamingSettings::TimeLimitExceededMinTime' has a wrong offset!");
static_assert(offsetof(UStreamingSettings, MinBulkDataSizeForAsyncLoading) == 0x000044, "Member 'UStreamingSettings::MinBulkDataSizeForAsyncLoading' has a wrong offset!");
static_assert(offsetof(UStreamingSettings, AsyncLoadingTimeLimit) == 0x00004C, "Member 'UStreamingSettings::AsyncLoadingTimeLimit' has a wrong offset!");
static_assert(offsetof(UStreamingSettings, PriorityAsyncLoadingExtraTime) == 0x000050, "Member 'UStreamingSettings::PriorityAsyncLoadingExtraTime' has a wrong offset!");
static_assert(offsetof(UStreamingSettings, LevelStreamingActorsUpdateTimeLimit) == 0x000054, "Member 'UStreamingSettings::LevelStreamingActorsUpdateTimeLimit' has a wrong offset!");
static_assert(offsetof(UStreamingSettings, PriorityLevelStreamingActorsUpdateExtraTime) == 0x000058, "Member 'UStreamingSettings::PriorityLevelStreamingActorsUpdateExtraTime' has a wrong offset!");
static_assert(offsetof(UStreamingSettings, LevelStreamingComponentsRegistrationGranularity) == 0x00005C, "Member 'UStreamingSettings::LevelStreamingComponentsRegistrationGranularity' has a wrong offset!");
static_assert(offsetof(UStreamingSettings, LevelStreamingAddPrimitiveGranularity) == 0x000060, "Member 'UStreamingSettings::LevelStreamingAddPrimitiveGranularity' has a wrong offset!");
static_assert(offsetof(UStreamingSettings, LevelStreamingUnregisterComponentsTimeLimit) == 0x000064, "Member 'UStreamingSettings::LevelStreamingUnregisterComponentsTimeLimit' has a wrong offset!");
static_assert(offsetof(UStreamingSettings, LevelStreamingComponentsUnregistrationGranularity) == 0x000068, "Member 'UStreamingSettings::LevelStreamingComponentsUnregistrationGranularity' has a wrong offset!");

// Class Engine.ParticleModuleSizeBase
// 0x0000 (0x0030 - 0x0030)
class UParticleModuleSizeBase : public UParticleModule
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ParticleModuleSizeBase">();
	}
	static class UParticleModuleSizeBase* GetDefaultObj()
	{
		return GetDefaultObjImpl<UParticleModuleSizeBase>();
	}
};
static_assert(alignof(UParticleModuleSizeBase) == 0x000008, "Wrong alignment on UParticleModuleSizeBase");
static_assert(sizeof(UParticleModuleSizeBase) == 0x000030, "Wrong size on UParticleModuleSizeBase");

// Class Engine.ParticleModuleSize
// 0x0060 (0x0090 - 0x0030)
class UParticleModuleSize : public UParticleModuleSizeBase
{
public:
	struct FRawDistributionVector                 StartSize;                                         // 0x0030(0x0060)(Edit, ContainsInstancedReference, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ParticleModuleSize">();
	}
	static class UParticleModuleSize* GetDefaultObj()
	{
		return GetDefaultObjImpl<UParticleModuleSize>();
	}
};
static_assert(alignof(UParticleModuleSize) == 0x000008, "Wrong alignment on UParticleModuleSize");
static_assert(sizeof(UParticleModuleSize) == 0x000090, "Wrong size on UParticleModuleSize");
static_assert(offsetof(UParticleModuleSize, StartSize) == 0x000030, "Member 'UParticleModuleSize::StartSize' has a wrong offset!");

// Class Engine.ParticleModuleSizeMultiplyLife
// 0x0068 (0x0098 - 0x0030)
class UParticleModuleSizeMultiplyLife final : public UParticleModuleSizeBase
{
public:
	struct FRawDistributionVector                 LifeMultiplier;                                    // 0x0030(0x0060)(Edit, ContainsInstancedReference, NativeAccessSpecifierPublic)
	uint8                                         MultiplyX : 1;                                     // 0x0090(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         MultiplyY : 1;                                     // 0x0090(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         MultiplyZ : 1;                                     // 0x0090(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_91[0x7];                                       // 0x0091(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ParticleModuleSizeMultiplyLife">();
	}
	static class UParticleModuleSizeMultiplyLife* GetDefaultObj()
	{
		return GetDefaultObjImpl<UParticleModuleSizeMultiplyLife>();
	}
};
static_assert(alignof(UParticleModuleSizeMultiplyLife) == 0x000008, "Wrong alignment on UParticleModuleSizeMultiplyLife");
static_assert(sizeof(UParticleModuleSizeMultiplyLife) == 0x000098, "Wrong size on UParticleModuleSizeMultiplyLife");
static_assert(offsetof(UParticleModuleSizeMultiplyLife, LifeMultiplier) == 0x000030, "Member 'UParticleModuleSizeMultiplyLife::LifeMultiplier' has a wrong offset!");

// Class Engine.ParticleModuleSizeScale
// 0x0068 (0x0098 - 0x0030)
class UParticleModuleSizeScale final : public UParticleModuleSizeBase
{
public:
	struct FRawDistributionVector                 SizeScale;                                         // 0x0030(0x0060)(Edit, ContainsInstancedReference, NativeAccessSpecifierPublic)
	uint8                                         EnableX : 1;                                       // 0x0090(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         EnableY : 1;                                       // 0x0090(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         EnableZ : 1;                                       // 0x0090(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_91[0x7];                                       // 0x0091(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ParticleModuleSizeScale">();
	}
	static class UParticleModuleSizeScale* GetDefaultObj()
	{
		return GetDefaultObjImpl<UParticleModuleSizeScale>();
	}
};
static_assert(alignof(UParticleModuleSizeScale) == 0x000008, "Wrong alignment on UParticleModuleSizeScale");
static_assert(sizeof(UParticleModuleSizeScale) == 0x000098, "Wrong size on UParticleModuleSizeScale");
static_assert(offsetof(UParticleModuleSizeScale, SizeScale) == 0x000030, "Member 'UParticleModuleSizeScale::SizeScale' has a wrong offset!");

// Class Engine.ParticleModuleSizeScaleBySpeed
// 0x0020 (0x0050 - 0x0030)
class UParticleModuleSizeScaleBySpeed final : public UParticleModuleSizeBase
{
public:
	struct FVector2D                              SpeedScale;                                        // 0x0030(0x0010)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector2D                              MaxScale;                                          // 0x0040(0x0010)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ParticleModuleSizeScaleBySpeed">();
	}
	static class UParticleModuleSizeScaleBySpeed* GetDefaultObj()
	{
		return GetDefaultObjImpl<UParticleModuleSizeScaleBySpeed>();
	}
};
static_assert(alignof(UParticleModuleSizeScaleBySpeed) == 0x000008, "Wrong alignment on UParticleModuleSizeScaleBySpeed");
static_assert(sizeof(UParticleModuleSizeScaleBySpeed) == 0x000050, "Wrong size on UParticleModuleSizeScaleBySpeed");
static_assert(offsetof(UParticleModuleSizeScaleBySpeed, SpeedScale) == 0x000030, "Member 'UParticleModuleSizeScaleBySpeed::SpeedScale' has a wrong offset!");
static_assert(offsetof(UParticleModuleSizeScaleBySpeed, MaxScale) == 0x000040, "Member 'UParticleModuleSizeScaleBySpeed::MaxScale' has a wrong offset!");

// Class Engine.ParticleModuleSize_Seeded
// 0x0020 (0x00B0 - 0x0090)
class UParticleModuleSize_Seeded final : public UParticleModuleSize
{
public:
	struct FParticleRandomSeedInfo                RandomSeedInfo;                                    // 0x0090(0x0020)(Edit, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ParticleModuleSize_Seeded">();
	}
	static class UParticleModuleSize_Seeded* GetDefaultObj()
	{
		return GetDefaultObjImpl<UParticleModuleSize_Seeded>();
	}
};
static_assert(alignof(UParticleModuleSize_Seeded) == 0x000008, "Wrong alignment on UParticleModuleSize_Seeded");
static_assert(sizeof(UParticleModuleSize_Seeded) == 0x0000B0, "Wrong size on UParticleModuleSize_Seeded");
static_assert(offsetof(UParticleModuleSize_Seeded, RandomSeedInfo) == 0x000090, "Member 'UParticleModuleSize_Seeded::RandomSeedInfo' has a wrong offset!");

// Class Engine.ParticleModuleSourceMovement
// 0x0060 (0x0090 - 0x0030)
class UParticleModuleSourceMovement final : public UParticleModuleLocationBase
{
public:
	struct FRawDistributionVector                 SourceMovementScale;                               // 0x0030(0x0060)(Edit, ContainsInstancedReference, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ParticleModuleSourceMovement">();
	}
	static class UParticleModuleSourceMovement* GetDefaultObj()
	{
		return GetDefaultObjImpl<UParticleModuleSourceMovement>();
	}
};
static_assert(alignof(UParticleModuleSourceMovement) == 0x000008, "Wrong alignment on UParticleModuleSourceMovement");
static_assert(sizeof(UParticleModuleSourceMovement) == 0x000090, "Wrong size on UParticleModuleSourceMovement");
static_assert(offsetof(UParticleModuleSourceMovement, SourceMovementScale) == 0x000030, "Member 'UParticleModuleSourceMovement::SourceMovementScale' has a wrong offset!");

// Class Engine.ParticleModuleSpawnBase
// 0x0008 (0x0038 - 0x0030)
class UParticleModuleSpawnBase : public UParticleModule
{
public:
	uint8                                         bProcessSpawnRate : 1;                             // 0x0030(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bProcessBurstList : 1;                             // 0x0030(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_31[0x7];                                       // 0x0031(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ParticleModuleSpawnBase">();
	}
	static class UParticleModuleSpawnBase* GetDefaultObj()
	{
		return GetDefaultObjImpl<UParticleModuleSpawnBase>();
	}
};
static_assert(alignof(UParticleModuleSpawnBase) == 0x000008, "Wrong alignment on UParticleModuleSpawnBase");
static_assert(sizeof(UParticleModuleSpawnBase) == 0x000038, "Wrong size on UParticleModuleSpawnBase");

// Class Engine.SystemTimeTimecodeProvider
// 0x0010 (0x0040 - 0x0030)
class USystemTimeTimecodeProvider final : public UTimecodeProvider
{
public:
	struct FFrameRate                             FrameRate;                                         // 0x0030(0x0008)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bGenerateFullFrame;                                // 0x0038(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bUseHighPerformanceClock;                          // 0x0039(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_3A[0x6];                                       // 0x003A(0x0006)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"SystemTimeTimecodeProvider">();
	}
	static class USystemTimeTimecodeProvider* GetDefaultObj()
	{
		return GetDefaultObjImpl<USystemTimeTimecodeProvider>();
	}
};
static_assert(alignof(USystemTimeTimecodeProvider) == 0x000008, "Wrong alignment on USystemTimeTimecodeProvider");
static_assert(sizeof(USystemTimeTimecodeProvider) == 0x000040, "Wrong size on USystemTimeTimecodeProvider");
static_assert(offsetof(USystemTimeTimecodeProvider, FrameRate) == 0x000030, "Member 'USystemTimeTimecodeProvider::FrameRate' has a wrong offset!");
static_assert(offsetof(USystemTimeTimecodeProvider, bGenerateFullFrame) == 0x000038, "Member 'USystemTimeTimecodeProvider::bGenerateFullFrame' has a wrong offset!");
static_assert(offsetof(USystemTimeTimecodeProvider, bUseHighPerformanceClock) == 0x000039, "Member 'USystemTimeTimecodeProvider::bUseHighPerformanceClock' has a wrong offset!");

// Class Engine.ParticleModuleSpawn
// 0x00A8 (0x00E0 - 0x0038)
class UParticleModuleSpawn final : public UParticleModuleSpawnBase
{
public:
	struct FRawDistributionFloat                  Rate;                                              // 0x0038(0x0030)(Edit, ContainsInstancedReference, NativeAccessSpecifierPublic)
	struct FRawDistributionFloat                  RateScale;                                         // 0x0068(0x0030)(Edit, ContainsInstancedReference, NativeAccessSpecifierPublic)
	TArray<struct FParticleBurst>                 BurstList;                                         // 0x0098(0x0010)(Edit, ExportObject, ZeroConstructor, NoClear, NativeAccessSpecifierPublic)
	struct FRawDistributionFloat                  BurstScale;                                        // 0x00A8(0x0030)(Edit, ContainsInstancedReference, NativeAccessSpecifierPublic)
	EParticleBurstMethod                          ParticleBurstMethod;                               // 0x00D8(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_D9[0x3];                                       // 0x00D9(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	uint8                                         bApplyGlobalSpawnRateScale : 1;                    // 0x00DC(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_DD[0x3];                                       // 0x00DD(0x0003)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ParticleModuleSpawn">();
	}
	static class UParticleModuleSpawn* GetDefaultObj()
	{
		return GetDefaultObjImpl<UParticleModuleSpawn>();
	}
};
static_assert(alignof(UParticleModuleSpawn) == 0x000008, "Wrong alignment on UParticleModuleSpawn");
static_assert(sizeof(UParticleModuleSpawn) == 0x0000E0, "Wrong size on UParticleModuleSpawn");
static_assert(offsetof(UParticleModuleSpawn, Rate) == 0x000038, "Member 'UParticleModuleSpawn::Rate' has a wrong offset!");
static_assert(offsetof(UParticleModuleSpawn, RateScale) == 0x000068, "Member 'UParticleModuleSpawn::RateScale' has a wrong offset!");
static_assert(offsetof(UParticleModuleSpawn, BurstList) == 0x000098, "Member 'UParticleModuleSpawn::BurstList' has a wrong offset!");
static_assert(offsetof(UParticleModuleSpawn, BurstScale) == 0x0000A8, "Member 'UParticleModuleSpawn::BurstScale' has a wrong offset!");
static_assert(offsetof(UParticleModuleSpawn, ParticleBurstMethod) == 0x0000D8, "Member 'UParticleModuleSpawn::ParticleBurstMethod' has a wrong offset!");

// Class Engine.ParticleModuleSpawnPerUnit
// 0x0040 (0x0078 - 0x0038)
class UParticleModuleSpawnPerUnit final : public UParticleModuleSpawnBase
{
public:
	float                                         UnitScalar;                                        // 0x0038(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         MovementTolerance;                                 // 0x003C(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FRawDistributionFloat                  SpawnPerUnit;                                      // 0x0040(0x0030)(Edit, ContainsInstancedReference, NativeAccessSpecifierPublic)
	float                                         MaxFrameDistance;                                  // 0x0070(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bIgnoreSpawnRateWhenMoving : 1;                    // 0x0074(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bIgnoreMovementAlongX : 1;                         // 0x0074(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bIgnoreMovementAlongY : 1;                         // 0x0074(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bIgnoreMovementAlongZ : 1;                         // 0x0074(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_75[0x3];                                       // 0x0075(0x0003)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ParticleModuleSpawnPerUnit">();
	}
	static class UParticleModuleSpawnPerUnit* GetDefaultObj()
	{
		return GetDefaultObjImpl<UParticleModuleSpawnPerUnit>();
	}
};
static_assert(alignof(UParticleModuleSpawnPerUnit) == 0x000008, "Wrong alignment on UParticleModuleSpawnPerUnit");
static_assert(sizeof(UParticleModuleSpawnPerUnit) == 0x000078, "Wrong size on UParticleModuleSpawnPerUnit");
static_assert(offsetof(UParticleModuleSpawnPerUnit, UnitScalar) == 0x000038, "Member 'UParticleModuleSpawnPerUnit::UnitScalar' has a wrong offset!");
static_assert(offsetof(UParticleModuleSpawnPerUnit, MovementTolerance) == 0x00003C, "Member 'UParticleModuleSpawnPerUnit::MovementTolerance' has a wrong offset!");
static_assert(offsetof(UParticleModuleSpawnPerUnit, SpawnPerUnit) == 0x000040, "Member 'UParticleModuleSpawnPerUnit::SpawnPerUnit' has a wrong offset!");
static_assert(offsetof(UParticleModuleSpawnPerUnit, MaxFrameDistance) == 0x000070, "Member 'UParticleModuleSpawnPerUnit::MaxFrameDistance' has a wrong offset!");

// Class Engine.ParticleModuleSubUVBase
// 0x0000 (0x0030 - 0x0030)
class UParticleModuleSubUVBase : public UParticleModule
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ParticleModuleSubUVBase">();
	}
	static class UParticleModuleSubUVBase* GetDefaultObj()
	{
		return GetDefaultObjImpl<UParticleModuleSubUVBase>();
	}
};
static_assert(alignof(UParticleModuleSubUVBase) == 0x000008, "Wrong alignment on UParticleModuleSubUVBase");
static_assert(sizeof(UParticleModuleSubUVBase) == 0x000030, "Wrong size on UParticleModuleSubUVBase");

// Class Engine.ParticleModuleSubUV
// 0x0040 (0x0070 - 0x0030)
class UParticleModuleSubUV : public UParticleModuleSubUVBase
{
public:
	class USubUVAnimation*                        Animation;                                         // 0x0030(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FRawDistributionFloat                  SubImageIndex;                                     // 0x0038(0x0030)(Edit, ContainsInstancedReference, NativeAccessSpecifierPublic)
	uint8                                         bUseRealTime : 1;                                  // 0x0068(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_69[0x7];                                       // 0x0069(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ParticleModuleSubUV">();
	}
	static class UParticleModuleSubUV* GetDefaultObj()
	{
		return GetDefaultObjImpl<UParticleModuleSubUV>();
	}
};
static_assert(alignof(UParticleModuleSubUV) == 0x000008, "Wrong alignment on UParticleModuleSubUV");
static_assert(sizeof(UParticleModuleSubUV) == 0x000070, "Wrong size on UParticleModuleSubUV");
static_assert(offsetof(UParticleModuleSubUV, Animation) == 0x000030, "Member 'UParticleModuleSubUV::Animation' has a wrong offset!");
static_assert(offsetof(UParticleModuleSubUV, SubImageIndex) == 0x000038, "Member 'UParticleModuleSubUV::SubImageIndex' has a wrong offset!");

// Class Engine.FontFace
// 0x0040 (0x0068 - 0x0028)
class UFontFace final : public UObject
{
public:
	uint8                                         Pad_28[0x8];                                       // 0x0028(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	class FString                                 SourceFilename;                                    // 0x0030(0x0010)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EFontHinting                                  Hinting;                                           // 0x0040(0x0001)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EFontLoadingPolicy                            LoadingPolicy;                                     // 0x0041(0x0001)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EFontLayoutMethod                             LayoutMethod;                                      // 0x0042(0x0001)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_43[0x1];                                       // 0x0043(0x0001)(Fixing Size After Last Property [ Dumper-7 ])
	int32                                         AscendOverriddenValue;                             // 0x0044(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bIsAscendOverridden;                               // 0x0048(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_49[0x3];                                       // 0x0049(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	int32                                         DescendOverriddenValue;                            // 0x004C(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bIsDescendOverridden;                              // 0x0050(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_51[0x17];                                      // 0x0051(0x0017)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"FontFace">();
	}
	static class UFontFace* GetDefaultObj()
	{
		return GetDefaultObjImpl<UFontFace>();
	}
};
static_assert(alignof(UFontFace) == 0x000008, "Wrong alignment on UFontFace");
static_assert(sizeof(UFontFace) == 0x000068, "Wrong size on UFontFace");
static_assert(offsetof(UFontFace, SourceFilename) == 0x000030, "Member 'UFontFace::SourceFilename' has a wrong offset!");
static_assert(offsetof(UFontFace, Hinting) == 0x000040, "Member 'UFontFace::Hinting' has a wrong offset!");
static_assert(offsetof(UFontFace, LoadingPolicy) == 0x000041, "Member 'UFontFace::LoadingPolicy' has a wrong offset!");
static_assert(offsetof(UFontFace, LayoutMethod) == 0x000042, "Member 'UFontFace::LayoutMethod' has a wrong offset!");
static_assert(offsetof(UFontFace, AscendOverriddenValue) == 0x000044, "Member 'UFontFace::AscendOverriddenValue' has a wrong offset!");
static_assert(offsetof(UFontFace, bIsAscendOverridden) == 0x000048, "Member 'UFontFace::bIsAscendOverridden' has a wrong offset!");
static_assert(offsetof(UFontFace, DescendOverriddenValue) == 0x00004C, "Member 'UFontFace::DescendOverriddenValue' has a wrong offset!");
static_assert(offsetof(UFontFace, bIsDescendOverridden) == 0x000050, "Member 'UFontFace::bIsDescendOverridden' has a wrong offset!");

// Class Engine.ParticleModuleSubUVMovie
// 0x0040 (0x00B0 - 0x0070)
class UParticleModuleSubUVMovie final : public UParticleModuleSubUV
{
public:
	uint8                                         bUseEmitterTime : 1;                               // 0x0070(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_71[0x7];                                       // 0x0071(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	struct FRawDistributionFloat                  FrameRate;                                         // 0x0078(0x0030)(Edit, ContainsInstancedReference, NativeAccessSpecifierPublic)
	int32                                         StartingFrame;                                     // 0x00A8(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_AC[0x4];                                       // 0x00AC(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ParticleModuleSubUVMovie">();
	}
	static class UParticleModuleSubUVMovie* GetDefaultObj()
	{
		return GetDefaultObjImpl<UParticleModuleSubUVMovie>();
	}
};
static_assert(alignof(UParticleModuleSubUVMovie) == 0x000008, "Wrong alignment on UParticleModuleSubUVMovie");
static_assert(sizeof(UParticleModuleSubUVMovie) == 0x0000B0, "Wrong size on UParticleModuleSubUVMovie");
static_assert(offsetof(UParticleModuleSubUVMovie, FrameRate) == 0x000078, "Member 'UParticleModuleSubUVMovie::FrameRate' has a wrong offset!");
static_assert(offsetof(UParticleModuleSubUVMovie, StartingFrame) == 0x0000A8, "Member 'UParticleModuleSubUVMovie::StartingFrame' has a wrong offset!");

// Class Engine.ParticleModuleTypeDataBase
// 0x0000 (0x0030 - 0x0030)
class UParticleModuleTypeDataBase : public UParticleModule
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ParticleModuleTypeDataBase">();
	}
	static class UParticleModuleTypeDataBase* GetDefaultObj()
	{
		return GetDefaultObjImpl<UParticleModuleTypeDataBase>();
	}
};
static_assert(alignof(UParticleModuleTypeDataBase) == 0x000008, "Wrong alignment on UParticleModuleTypeDataBase");
static_assert(sizeof(UParticleModuleTypeDataBase) == 0x000030, "Wrong size on UParticleModuleTypeDataBase");

// Class Engine.ParticleModuleTypeDataAnimTrail
// 0x0018 (0x0048 - 0x0030)
class UParticleModuleTypeDataAnimTrail final : public UParticleModuleTypeDataBase
{
public:
	uint8                                         bDeadTrailsOnDeactivate : 1;                       // 0x0030(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bEnablePreviousTangentRecalculation : 1;           // 0x0030(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bTangentRecalculationEveryFrame : 1;               // 0x0030(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_31[0x3];                                       // 0x0031(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         TilingDistance;                                    // 0x0034(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         DistanceTessellationStepSize;                      // 0x0038(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         TangentTessellationStepSize;                       // 0x003C(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         WidthTessellationStepSize;                         // 0x0040(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_44[0x4];                                       // 0x0044(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ParticleModuleTypeDataAnimTrail">();
	}
	static class UParticleModuleTypeDataAnimTrail* GetDefaultObj()
	{
		return GetDefaultObjImpl<UParticleModuleTypeDataAnimTrail>();
	}
};
static_assert(alignof(UParticleModuleTypeDataAnimTrail) == 0x000008, "Wrong alignment on UParticleModuleTypeDataAnimTrail");
static_assert(sizeof(UParticleModuleTypeDataAnimTrail) == 0x000048, "Wrong size on UParticleModuleTypeDataAnimTrail");
static_assert(offsetof(UParticleModuleTypeDataAnimTrail, TilingDistance) == 0x000034, "Member 'UParticleModuleTypeDataAnimTrail::TilingDistance' has a wrong offset!");
static_assert(offsetof(UParticleModuleTypeDataAnimTrail, DistanceTessellationStepSize) == 0x000038, "Member 'UParticleModuleTypeDataAnimTrail::DistanceTessellationStepSize' has a wrong offset!");
static_assert(offsetof(UParticleModuleTypeDataAnimTrail, TangentTessellationStepSize) == 0x00003C, "Member 'UParticleModuleTypeDataAnimTrail::TangentTessellationStepSize' has a wrong offset!");
static_assert(offsetof(UParticleModuleTypeDataAnimTrail, WidthTessellationStepSize) == 0x000040, "Member 'UParticleModuleTypeDataAnimTrail::WidthTessellationStepSize' has a wrong offset!");

// Class Engine.ParticleModuleTypeDataBeam2
// 0x0120 (0x0150 - 0x0030)
class UParticleModuleTypeDataBeam2 final : public UParticleModuleTypeDataBase
{
public:
	EBeam2Method                                  BeamMethod;                                        // 0x0030(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_31[0x3];                                       // 0x0031(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	int32                                         TextureTile;                                       // 0x0034(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         TextureTileDistance;                               // 0x0038(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         Sheets;                                            // 0x003C(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         MaxBeamCount;                                      // 0x0040(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         Speed;                                             // 0x0044(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         InterpolationPoints;                               // 0x0048(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bAlwaysOn : 1;                                     // 0x004C(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_4D[0x3];                                       // 0x004D(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	int32                                         UpVectorStepSize;                                  // 0x0050(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FName                                   BranchParentName;                                  // 0x0054(0x0008)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_5C[0x4];                                       // 0x005C(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	struct FRawDistributionFloat                  Distance;                                          // 0x0060(0x0030)(Edit, ContainsInstancedReference, NativeAccessSpecifierPublic)
	EBeamTaperMethod                              TaperMethod;                                       // 0x0090(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_91[0x7];                                       // 0x0091(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	struct FRawDistributionFloat                  TaperFactor;                                       // 0x0098(0x0030)(Edit, ContainsInstancedReference, NativeAccessSpecifierPublic)
	struct FRawDistributionFloat                  TaperScale;                                        // 0x00C8(0x0030)(Edit, ContainsInstancedReference, NativeAccessSpecifierPublic)
	uint8                                         RenderGeometry : 1;                                // 0x00F8(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         RenderDirectLine : 1;                              // 0x00F8(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         RenderLines : 1;                                   // 0x00F8(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         RenderTessellation : 1;                            // 0x00F8(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_F9[0x57];                                      // 0x00F9(0x0057)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ParticleModuleTypeDataBeam2">();
	}
	static class UParticleModuleTypeDataBeam2* GetDefaultObj()
	{
		return GetDefaultObjImpl<UParticleModuleTypeDataBeam2>();
	}
};
static_assert(alignof(UParticleModuleTypeDataBeam2) == 0x000008, "Wrong alignment on UParticleModuleTypeDataBeam2");
static_assert(sizeof(UParticleModuleTypeDataBeam2) == 0x000150, "Wrong size on UParticleModuleTypeDataBeam2");
static_assert(offsetof(UParticleModuleTypeDataBeam2, BeamMethod) == 0x000030, "Member 'UParticleModuleTypeDataBeam2::BeamMethod' has a wrong offset!");
static_assert(offsetof(UParticleModuleTypeDataBeam2, TextureTile) == 0x000034, "Member 'UParticleModuleTypeDataBeam2::TextureTile' has a wrong offset!");
static_assert(offsetof(UParticleModuleTypeDataBeam2, TextureTileDistance) == 0x000038, "Member 'UParticleModuleTypeDataBeam2::TextureTileDistance' has a wrong offset!");
static_assert(offsetof(UParticleModuleTypeDataBeam2, Sheets) == 0x00003C, "Member 'UParticleModuleTypeDataBeam2::Sheets' has a wrong offset!");
static_assert(offsetof(UParticleModuleTypeDataBeam2, MaxBeamCount) == 0x000040, "Member 'UParticleModuleTypeDataBeam2::MaxBeamCount' has a wrong offset!");
static_assert(offsetof(UParticleModuleTypeDataBeam2, Speed) == 0x000044, "Member 'UParticleModuleTypeDataBeam2::Speed' has a wrong offset!");
static_assert(offsetof(UParticleModuleTypeDataBeam2, InterpolationPoints) == 0x000048, "Member 'UParticleModuleTypeDataBeam2::InterpolationPoints' has a wrong offset!");
static_assert(offsetof(UParticleModuleTypeDataBeam2, UpVectorStepSize) == 0x000050, "Member 'UParticleModuleTypeDataBeam2::UpVectorStepSize' has a wrong offset!");
static_assert(offsetof(UParticleModuleTypeDataBeam2, BranchParentName) == 0x000054, "Member 'UParticleModuleTypeDataBeam2::BranchParentName' has a wrong offset!");
static_assert(offsetof(UParticleModuleTypeDataBeam2, Distance) == 0x000060, "Member 'UParticleModuleTypeDataBeam2::Distance' has a wrong offset!");
static_assert(offsetof(UParticleModuleTypeDataBeam2, TaperMethod) == 0x000090, "Member 'UParticleModuleTypeDataBeam2::TaperMethod' has a wrong offset!");
static_assert(offsetof(UParticleModuleTypeDataBeam2, TaperFactor) == 0x000098, "Member 'UParticleModuleTypeDataBeam2::TaperFactor' has a wrong offset!");
static_assert(offsetof(UParticleModuleTypeDataBeam2, TaperScale) == 0x0000C8, "Member 'UParticleModuleTypeDataBeam2::TaperScale' has a wrong offset!");

// Class Engine.ParticleModuleTypeDataGpu
// 0x05A0 (0x05D0 - 0x0030)
class UParticleModuleTypeDataGpu final : public UParticleModuleTypeDataBase
{
public:
	struct FGPUSpriteEmitterInfo                  EmitterInfo;                                       // 0x0030(0x0350)(ContainsInstancedReference, NativeAccessSpecifierPublic)
	struct FGPUSpriteResourceData                 ResourceData;                                      // 0x0380(0x0240)(NativeAccessSpecifierPublic)
	float                                         CameraMotionBlurAmount;                            // 0x05C0(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bClearExistingParticlesOnInit : 1;                 // 0x05C4(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_5C5[0xB];                                      // 0x05C5(0x000B)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ParticleModuleTypeDataGpu">();
	}
	static class UParticleModuleTypeDataGpu* GetDefaultObj()
	{
		return GetDefaultObjImpl<UParticleModuleTypeDataGpu>();
	}
};
static_assert(alignof(UParticleModuleTypeDataGpu) == 0x000010, "Wrong alignment on UParticleModuleTypeDataGpu");
static_assert(sizeof(UParticleModuleTypeDataGpu) == 0x0005D0, "Wrong size on UParticleModuleTypeDataGpu");
static_assert(offsetof(UParticleModuleTypeDataGpu, EmitterInfo) == 0x000030, "Member 'UParticleModuleTypeDataGpu::EmitterInfo' has a wrong offset!");
static_assert(offsetof(UParticleModuleTypeDataGpu, ResourceData) == 0x000380, "Member 'UParticleModuleTypeDataGpu::ResourceData' has a wrong offset!");
static_assert(offsetof(UParticleModuleTypeDataGpu, CameraMotionBlurAmount) == 0x0005C0, "Member 'UParticleModuleTypeDataGpu::CameraMotionBlurAmount' has a wrong offset!");

// Class Engine.AnimMetaData
// 0x0000 (0x0028 - 0x0028)
class UAnimMetaData final : public UObject
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AnimMetaData">();
	}
	static class UAnimMetaData* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAnimMetaData>();
	}
};
static_assert(alignof(UAnimMetaData) == 0x000008, "Wrong alignment on UAnimMetaData");
static_assert(sizeof(UAnimMetaData) == 0x000028, "Wrong size on UAnimMetaData");

// Class Engine.ParticleModuleTypeDataMesh
// 0x0080 (0x00B0 - 0x0030)
class UParticleModuleTypeDataMesh final : public UParticleModuleTypeDataBase
{
public:
	class UStaticMesh*                            mesh;                                              // 0x0030(0x0008)(Edit, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_38[0x8];                                       // 0x0038(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         LODSizeScale;                                      // 0x0040(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bUseStaticMeshLODs : 1;                            // 0x0044(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         CastShadows : 1;                                   // 0x0044(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         DoCollisions : 1;                                  // 0x0044(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	EMeshScreenAlignment                          MeshAlignment;                                     // 0x0045(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bOverrideMaterial : 1;                             // 0x0046(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bOverrideDefaultMotionBlurSettings : 1;            // 0x0046(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bEnableMotionBlur : 1;                             // 0x0046(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_47[0x1];                                       // 0x0047(0x0001)(Fixing Size After Last Property [ Dumper-7 ])
	struct FRawDistributionVector                 RollPitchYawRange;                                 // 0x0048(0x0060)(Edit, ContainsInstancedReference, NativeAccessSpecifierPublic)
	EParticleAxisLock                             AxisLockOption;                                    // 0x00A8(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bCameraFacing : 1;                                 // 0x00A9(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	EMeshCameraFacingUpAxis                       CameraFacingUpAxisOption;                          // 0x00AA(0x0001)(ZeroConstructor, Deprecated, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EMeshCameraFacingOptions                      CameraFacingOption;                                // 0x00AB(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bApplyParticleRotationAsSpin : 1;                  // 0x00AC(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bFaceCameraDirectionRatherThanPosition : 1;        // 0x00AC(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bCollisionsConsiderPartilceSize : 1;               // 0x00AC(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_AD[0x3];                                       // 0x00AD(0x0003)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ParticleModuleTypeDataMesh">();
	}
	static class UParticleModuleTypeDataMesh* GetDefaultObj()
	{
		return GetDefaultObjImpl<UParticleModuleTypeDataMesh>();
	}
};
static_assert(alignof(UParticleModuleTypeDataMesh) == 0x000008, "Wrong alignment on UParticleModuleTypeDataMesh");
static_assert(sizeof(UParticleModuleTypeDataMesh) == 0x0000B0, "Wrong size on UParticleModuleTypeDataMesh");
static_assert(offsetof(UParticleModuleTypeDataMesh, mesh) == 0x000030, "Member 'UParticleModuleTypeDataMesh::mesh' has a wrong offset!");
static_assert(offsetof(UParticleModuleTypeDataMesh, LODSizeScale) == 0x000040, "Member 'UParticleModuleTypeDataMesh::LODSizeScale' has a wrong offset!");
static_assert(offsetof(UParticleModuleTypeDataMesh, MeshAlignment) == 0x000045, "Member 'UParticleModuleTypeDataMesh::MeshAlignment' has a wrong offset!");
static_assert(offsetof(UParticleModuleTypeDataMesh, RollPitchYawRange) == 0x000048, "Member 'UParticleModuleTypeDataMesh::RollPitchYawRange' has a wrong offset!");
static_assert(offsetof(UParticleModuleTypeDataMesh, AxisLockOption) == 0x0000A8, "Member 'UParticleModuleTypeDataMesh::AxisLockOption' has a wrong offset!");
static_assert(offsetof(UParticleModuleTypeDataMesh, CameraFacingUpAxisOption) == 0x0000AA, "Member 'UParticleModuleTypeDataMesh::CameraFacingUpAxisOption' has a wrong offset!");
static_assert(offsetof(UParticleModuleTypeDataMesh, CameraFacingOption) == 0x0000AB, "Member 'UParticleModuleTypeDataMesh::CameraFacingOption' has a wrong offset!");

// Class Engine.ParticleModuleTypeDataRibbon
// 0x0030 (0x0060 - 0x0030)
class UParticleModuleTypeDataRibbon final : public UParticleModuleTypeDataBase
{
public:
	int32                                         MaxTessellationBetweenParticles;                   // 0x0030(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         SheetsPerTrail;                                    // 0x0034(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         MaxTrailCount;                                     // 0x0038(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         MaxParticleInTrailCount;                           // 0x003C(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bDeadTrailsOnDeactivate : 1;                       // 0x0040(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bDeadTrailsOnSourceLoss : 1;                       // 0x0040(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bClipSourceSegement : 1;                           // 0x0040(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bEnablePreviousTangentRecalculation : 1;           // 0x0040(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bTangentRecalculationEveryFrame : 1;               // 0x0040(0x0001)(BitIndex: 0x04, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bSpawnInitialParticle : 1;                         // 0x0040(0x0001)(BitIndex: 0x05, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_41[0x3];                                       // 0x0041(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	ETrailsRenderAxisOption                       RenderAxis;                                        // 0x0044(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_45[0x3];                                       // 0x0045(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         TangentSpawningScalar;                             // 0x0048(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bRenderGeometry : 1;                               // 0x004C(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bRenderSpawnPoints : 1;                            // 0x004C(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bRenderTangents : 1;                               // 0x004C(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bRenderTessellation : 1;                           // 0x004C(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_4D[0x3];                                       // 0x004D(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         TilingDistance;                                    // 0x0050(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         DistanceTessellationStepSize;                      // 0x0054(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bEnableTangentDiffInterpScale : 1;                 // 0x0058(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_59[0x3];                                       // 0x0059(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         TangentTessellationScalar;                         // 0x005C(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ParticleModuleTypeDataRibbon">();
	}
	static class UParticleModuleTypeDataRibbon* GetDefaultObj()
	{
		return GetDefaultObjImpl<UParticleModuleTypeDataRibbon>();
	}
};
static_assert(alignof(UParticleModuleTypeDataRibbon) == 0x000008, "Wrong alignment on UParticleModuleTypeDataRibbon");
static_assert(sizeof(UParticleModuleTypeDataRibbon) == 0x000060, "Wrong size on UParticleModuleTypeDataRibbon");
static_assert(offsetof(UParticleModuleTypeDataRibbon, MaxTessellationBetweenParticles) == 0x000030, "Member 'UParticleModuleTypeDataRibbon::MaxTessellationBetweenParticles' has a wrong offset!");
static_assert(offsetof(UParticleModuleTypeDataRibbon, SheetsPerTrail) == 0x000034, "Member 'UParticleModuleTypeDataRibbon::SheetsPerTrail' has a wrong offset!");
static_assert(offsetof(UParticleModuleTypeDataRibbon, MaxTrailCount) == 0x000038, "Member 'UParticleModuleTypeDataRibbon::MaxTrailCount' has a wrong offset!");
static_assert(offsetof(UParticleModuleTypeDataRibbon, MaxParticleInTrailCount) == 0x00003C, "Member 'UParticleModuleTypeDataRibbon::MaxParticleInTrailCount' has a wrong offset!");
static_assert(offsetof(UParticleModuleTypeDataRibbon, RenderAxis) == 0x000044, "Member 'UParticleModuleTypeDataRibbon::RenderAxis' has a wrong offset!");
static_assert(offsetof(UParticleModuleTypeDataRibbon, TangentSpawningScalar) == 0x000048, "Member 'UParticleModuleTypeDataRibbon::TangentSpawningScalar' has a wrong offset!");
static_assert(offsetof(UParticleModuleTypeDataRibbon, TilingDistance) == 0x000050, "Member 'UParticleModuleTypeDataRibbon::TilingDistance' has a wrong offset!");
static_assert(offsetof(UParticleModuleTypeDataRibbon, DistanceTessellationStepSize) == 0x000054, "Member 'UParticleModuleTypeDataRibbon::DistanceTessellationStepSize' has a wrong offset!");
static_assert(offsetof(UParticleModuleTypeDataRibbon, TangentTessellationScalar) == 0x00005C, "Member 'UParticleModuleTypeDataRibbon::TangentTessellationScalar' has a wrong offset!");

// Class Engine.ParticleModuleVectorFieldBase
// 0x0000 (0x0030 - 0x0030)
class UParticleModuleVectorFieldBase : public UParticleModule
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ParticleModuleVectorFieldBase">();
	}
	static class UParticleModuleVectorFieldBase* GetDefaultObj()
	{
		return GetDefaultObjImpl<UParticleModuleVectorFieldBase>();
	}
};
static_assert(alignof(UParticleModuleVectorFieldBase) == 0x000008, "Wrong alignment on UParticleModuleVectorFieldBase");
static_assert(sizeof(UParticleModuleVectorFieldBase) == 0x000030, "Wrong size on UParticleModuleVectorFieldBase");

// Class Engine.ParticleModuleVectorFieldGlobal
// 0x0010 (0x0040 - 0x0030)
class UParticleModuleVectorFieldGlobal final : public UParticleModuleVectorFieldBase
{
public:
	uint8                                         bOverrideGlobalVectorFieldTightness : 1;           // 0x0030(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_31[0x3];                                       // 0x0031(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         GlobalVectorFieldScale;                            // 0x0034(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         GlobalVectorFieldTightness;                        // 0x0038(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_3C[0x4];                                       // 0x003C(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ParticleModuleVectorFieldGlobal">();
	}
	static class UParticleModuleVectorFieldGlobal* GetDefaultObj()
	{
		return GetDefaultObjImpl<UParticleModuleVectorFieldGlobal>();
	}
};
static_assert(alignof(UParticleModuleVectorFieldGlobal) == 0x000008, "Wrong alignment on UParticleModuleVectorFieldGlobal");
static_assert(sizeof(UParticleModuleVectorFieldGlobal) == 0x000040, "Wrong size on UParticleModuleVectorFieldGlobal");
static_assert(offsetof(UParticleModuleVectorFieldGlobal, GlobalVectorFieldScale) == 0x000034, "Member 'UParticleModuleVectorFieldGlobal::GlobalVectorFieldScale' has a wrong offset!");
static_assert(offsetof(UParticleModuleVectorFieldGlobal, GlobalVectorFieldTightness) == 0x000038, "Member 'UParticleModuleVectorFieldGlobal::GlobalVectorFieldTightness' has a wrong offset!");

// Class Engine.AnimNotifyStateMachineInspectionLibrary
// 0x0000 (0x0028 - 0x0028)
class UAnimNotifyStateMachineInspectionLibrary final : public UBlueprintFunctionLibrary
{
public:
	static bool IsTriggeredByState(const struct FAnimNotifyEventReference& EventReference, class UAnimInstance* AnimInstance, class FName StateName);
	static bool IsTriggeredByStateInStateMachine(const struct FAnimNotifyEventReference& EventReference, class UAnimInstance* AnimInstance, class FName StateMachineName, class FName StateName);
	static bool IsTriggeredByStateMachine(const struct FAnimNotifyEventReference& EventReference, class UAnimInstance* AnimInstance, class FName StateMachineName);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AnimNotifyStateMachineInspectionLibrary">();
	}
	static class UAnimNotifyStateMachineInspectionLibrary* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAnimNotifyStateMachineInspectionLibrary>();
	}
};
static_assert(alignof(UAnimNotifyStateMachineInspectionLibrary) == 0x000008, "Wrong alignment on UAnimNotifyStateMachineInspectionLibrary");
static_assert(sizeof(UAnimNotifyStateMachineInspectionLibrary) == 0x000028, "Wrong size on UAnimNotifyStateMachineInspectionLibrary");

// Class Engine.ParticleModuleVectorFieldLocal
// 0x0060 (0x0090 - 0x0030)
class UParticleModuleVectorFieldLocal final : public UParticleModuleVectorFieldBase
{
public:
	class UVectorField*                           VectorField;                                       // 0x0030(0x0008)(Edit, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector                                RelativeTranslation;                               // 0x0038(0x0018)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FRotator                               RelativeRotation;                                  // 0x0050(0x0018)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
	struct FVector                                RelativeScale3D;                                   // 0x0068(0x0018)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         Intensity;                                         // 0x0080(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         Tightness;                                         // 0x0084(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bIgnoreComponentTransform : 1;                     // 0x0088(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bTileX : 1;                                        // 0x0088(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bTileY : 1;                                        // 0x0088(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bTileZ : 1;                                        // 0x0088(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bUseFixDT : 1;                                     // 0x0088(0x0001)(BitIndex: 0x04, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_89[0x7];                                       // 0x0089(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ParticleModuleVectorFieldLocal">();
	}
	static class UParticleModuleVectorFieldLocal* GetDefaultObj()
	{
		return GetDefaultObjImpl<UParticleModuleVectorFieldLocal>();
	}
};
static_assert(alignof(UParticleModuleVectorFieldLocal) == 0x000008, "Wrong alignment on UParticleModuleVectorFieldLocal");
static_assert(sizeof(UParticleModuleVectorFieldLocal) == 0x000090, "Wrong size on UParticleModuleVectorFieldLocal");
static_assert(offsetof(UParticleModuleVectorFieldLocal, VectorField) == 0x000030, "Member 'UParticleModuleVectorFieldLocal::VectorField' has a wrong offset!");
static_assert(offsetof(UParticleModuleVectorFieldLocal, RelativeTranslation) == 0x000038, "Member 'UParticleModuleVectorFieldLocal::RelativeTranslation' has a wrong offset!");
static_assert(offsetof(UParticleModuleVectorFieldLocal, RelativeRotation) == 0x000050, "Member 'UParticleModuleVectorFieldLocal::RelativeRotation' has a wrong offset!");
static_assert(offsetof(UParticleModuleVectorFieldLocal, RelativeScale3D) == 0x000068, "Member 'UParticleModuleVectorFieldLocal::RelativeScale3D' has a wrong offset!");
static_assert(offsetof(UParticleModuleVectorFieldLocal, Intensity) == 0x000080, "Member 'UParticleModuleVectorFieldLocal::Intensity' has a wrong offset!");
static_assert(offsetof(UParticleModuleVectorFieldLocal, Tightness) == 0x000084, "Member 'UParticleModuleVectorFieldLocal::Tightness' has a wrong offset!");

// Class Engine.ParticleModuleVectorFieldRotation
// 0x0030 (0x0060 - 0x0030)
class UParticleModuleVectorFieldRotation final : public UParticleModuleVectorFieldBase
{
public:
	struct FVector                                MinInitialRotation;                                // 0x0030(0x0018)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector                                MaxInitialRotation;                                // 0x0048(0x0018)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ParticleModuleVectorFieldRotation">();
	}
	static class UParticleModuleVectorFieldRotation* GetDefaultObj()
	{
		return GetDefaultObjImpl<UParticleModuleVectorFieldRotation>();
	}
};
static_assert(alignof(UParticleModuleVectorFieldRotation) == 0x000008, "Wrong alignment on UParticleModuleVectorFieldRotation");
static_assert(sizeof(UParticleModuleVectorFieldRotation) == 0x000060, "Wrong size on UParticleModuleVectorFieldRotation");
static_assert(offsetof(UParticleModuleVectorFieldRotation, MinInitialRotation) == 0x000030, "Member 'UParticleModuleVectorFieldRotation::MinInitialRotation' has a wrong offset!");
static_assert(offsetof(UParticleModuleVectorFieldRotation, MaxInitialRotation) == 0x000048, "Member 'UParticleModuleVectorFieldRotation::MaxInitialRotation' has a wrong offset!");

// Class Engine.ParticleModuleVectorFieldRotationRate
// 0x0018 (0x0048 - 0x0030)
class UParticleModuleVectorFieldRotationRate final : public UParticleModuleVectorFieldBase
{
public:
	struct FVector                                RotationRate;                                      // 0x0030(0x0018)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ParticleModuleVectorFieldRotationRate">();
	}
	static class UParticleModuleVectorFieldRotationRate* GetDefaultObj()
	{
		return GetDefaultObjImpl<UParticleModuleVectorFieldRotationRate>();
	}
};
static_assert(alignof(UParticleModuleVectorFieldRotationRate) == 0x000008, "Wrong alignment on UParticleModuleVectorFieldRotationRate");
static_assert(sizeof(UParticleModuleVectorFieldRotationRate) == 0x000048, "Wrong size on UParticleModuleVectorFieldRotationRate");
static_assert(offsetof(UParticleModuleVectorFieldRotationRate, RotationRate) == 0x000030, "Member 'UParticleModuleVectorFieldRotationRate::RotationRate' has a wrong offset!");

// Class Engine.ParticleModuleVectorFieldScale
// 0x0038 (0x0068 - 0x0030)
class UParticleModuleVectorFieldScale final : public UParticleModuleVectorFieldBase
{
public:
	class UDistributionFloat*                     VectorFieldScale;                                  // 0x0030(0x0008)(ExportObject, ZeroConstructor, InstancedReference, Deprecated, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FRawDistributionFloat                  VectorFieldScaleRaw;                               // 0x0038(0x0030)(Edit, ContainsInstancedReference, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ParticleModuleVectorFieldScale">();
	}
	static class UParticleModuleVectorFieldScale* GetDefaultObj()
	{
		return GetDefaultObjImpl<UParticleModuleVectorFieldScale>();
	}
};
static_assert(alignof(UParticleModuleVectorFieldScale) == 0x000008, "Wrong alignment on UParticleModuleVectorFieldScale");
static_assert(sizeof(UParticleModuleVectorFieldScale) == 0x000068, "Wrong size on UParticleModuleVectorFieldScale");
static_assert(offsetof(UParticleModuleVectorFieldScale, VectorFieldScale) == 0x000030, "Member 'UParticleModuleVectorFieldScale::VectorFieldScale' has a wrong offset!");
static_assert(offsetof(UParticleModuleVectorFieldScale, VectorFieldScaleRaw) == 0x000038, "Member 'UParticleModuleVectorFieldScale::VectorFieldScaleRaw' has a wrong offset!");

// Class Engine.AnimNotify_PauseClothingSimulation
// 0x0000 (0x0038 - 0x0038)
class UAnimNotify_PauseClothingSimulation final : public UAnimNotify
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AnimNotify_PauseClothingSimulation">();
	}
	static class UAnimNotify_PauseClothingSimulation* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAnimNotify_PauseClothingSimulation>();
	}
};
static_assert(alignof(UAnimNotify_PauseClothingSimulation) == 0x000008, "Wrong alignment on UAnimNotify_PauseClothingSimulation");
static_assert(sizeof(UAnimNotify_PauseClothingSimulation) == 0x000038, "Wrong size on UAnimNotify_PauseClothingSimulation");

// Class Engine.ParticleModuleVectorFieldScaleOverLife
// 0x0038 (0x0068 - 0x0030)
class UParticleModuleVectorFieldScaleOverLife final : public UParticleModuleVectorFieldBase
{
public:
	class UDistributionFloat*                     VectorFieldScaleOverLife;                          // 0x0030(0x0008)(ExportObject, ZeroConstructor, InstancedReference, Deprecated, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FRawDistributionFloat                  VectorFieldScaleOverLifeRaw;                       // 0x0038(0x0030)(Edit, ContainsInstancedReference, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ParticleModuleVectorFieldScaleOverLife">();
	}
	static class UParticleModuleVectorFieldScaleOverLife* GetDefaultObj()
	{
		return GetDefaultObjImpl<UParticleModuleVectorFieldScaleOverLife>();
	}
};
static_assert(alignof(UParticleModuleVectorFieldScaleOverLife) == 0x000008, "Wrong alignment on UParticleModuleVectorFieldScaleOverLife");
static_assert(sizeof(UParticleModuleVectorFieldScaleOverLife) == 0x000068, "Wrong size on UParticleModuleVectorFieldScaleOverLife");
static_assert(offsetof(UParticleModuleVectorFieldScaleOverLife, VectorFieldScaleOverLife) == 0x000030, "Member 'UParticleModuleVectorFieldScaleOverLife::VectorFieldScaleOverLife' has a wrong offset!");
static_assert(offsetof(UParticleModuleVectorFieldScaleOverLife, VectorFieldScaleOverLifeRaw) == 0x000038, "Member 'UParticleModuleVectorFieldScaleOverLife::VectorFieldScaleOverLifeRaw' has a wrong offset!");

// Class Engine.ParticleModuleVelocityBase
// 0x0008 (0x0038 - 0x0030)
class UParticleModuleVelocityBase : public UParticleModule
{
public:
	uint8                                         bInWorldSpace : 1;                                 // 0x0030(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bApplyOwnerScale : 1;                              // 0x0030(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_31[0x7];                                       // 0x0031(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ParticleModuleVelocityBase">();
	}
	static class UParticleModuleVelocityBase* GetDefaultObj()
	{
		return GetDefaultObjImpl<UParticleModuleVelocityBase>();
	}
};
static_assert(alignof(UParticleModuleVelocityBase) == 0x000008, "Wrong alignment on UParticleModuleVelocityBase");
static_assert(sizeof(UParticleModuleVelocityBase) == 0x000038, "Wrong size on UParticleModuleVelocityBase");

// Class Engine.ParticleModuleVelocity
// 0x0090 (0x00C8 - 0x0038)
class UParticleModuleVelocity : public UParticleModuleVelocityBase
{
public:
	struct FRawDistributionVector                 StartVelocity;                                     // 0x0038(0x0060)(Edit, ContainsInstancedReference, NativeAccessSpecifierPublic)
	struct FRawDistributionFloat                  StartVelocityRadial;                               // 0x0098(0x0030)(Edit, ContainsInstancedReference, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ParticleModuleVelocity">();
	}
	static class UParticleModuleVelocity* GetDefaultObj()
	{
		return GetDefaultObjImpl<UParticleModuleVelocity>();
	}
};
static_assert(alignof(UParticleModuleVelocity) == 0x000008, "Wrong alignment on UParticleModuleVelocity");
static_assert(sizeof(UParticleModuleVelocity) == 0x0000C8, "Wrong size on UParticleModuleVelocity");
static_assert(offsetof(UParticleModuleVelocity, StartVelocity) == 0x000038, "Member 'UParticleModuleVelocity::StartVelocity' has a wrong offset!");
static_assert(offsetof(UParticleModuleVelocity, StartVelocityRadial) == 0x000098, "Member 'UParticleModuleVelocity::StartVelocityRadial' has a wrong offset!");

// Class Engine.ParticleModuleVelocityCone
// 0x0078 (0x00B0 - 0x0038)
class UParticleModuleVelocityCone final : public UParticleModuleVelocityBase
{
public:
	struct FRawDistributionFloat                  Angle;                                             // 0x0038(0x0030)(Edit, ContainsInstancedReference, NativeAccessSpecifierPublic)
	struct FRawDistributionFloat                  Velocity;                                          // 0x0068(0x0030)(Edit, ContainsInstancedReference, NativeAccessSpecifierPublic)
	struct FVector                                Direction;                                         // 0x0098(0x0018)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ParticleModuleVelocityCone">();
	}
	static class UParticleModuleVelocityCone* GetDefaultObj()
	{
		return GetDefaultObjImpl<UParticleModuleVelocityCone>();
	}
};
static_assert(alignof(UParticleModuleVelocityCone) == 0x000008, "Wrong alignment on UParticleModuleVelocityCone");
static_assert(sizeof(UParticleModuleVelocityCone) == 0x0000B0, "Wrong size on UParticleModuleVelocityCone");
static_assert(offsetof(UParticleModuleVelocityCone, Angle) == 0x000038, "Member 'UParticleModuleVelocityCone::Angle' has a wrong offset!");
static_assert(offsetof(UParticleModuleVelocityCone, Velocity) == 0x000068, "Member 'UParticleModuleVelocityCone::Velocity' has a wrong offset!");
static_assert(offsetof(UParticleModuleVelocityCone, Direction) == 0x000098, "Member 'UParticleModuleVelocityCone::Direction' has a wrong offset!");

// Class Engine.AnimNotify_ResetDynamics
// 0x0000 (0x0038 - 0x0038)
class UAnimNotify_ResetDynamics final : public UAnimNotify
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AnimNotify_ResetDynamics">();
	}
	static class UAnimNotify_ResetDynamics* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAnimNotify_ResetDynamics>();
	}
};
static_assert(alignof(UAnimNotify_ResetDynamics) == 0x000008, "Wrong alignment on UAnimNotify_ResetDynamics");
static_assert(sizeof(UAnimNotify_ResetDynamics) == 0x000038, "Wrong size on UAnimNotify_ResetDynamics");

// Class Engine.WorldPartitionRuntimeCell
// 0x0060 (0x0088 - 0x0028)
class UWorldPartitionRuntimeCell : public UObject
{
public:
	uint8                                         Pad_28[0x8];                                       // 0x0028(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	bool                                          bIsAlwaysLoaded;                                   // 0x0030(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_31[0x7];                                       // 0x0031(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<class FName>                           DataLayers;                                        // 0x0038(0x0010)(ZeroConstructor, NativeAccessSpecifierPrivate)
	int32                                         Priority;                                          // 0x0048(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	bool                                          bClientOnlyVisible;                                // 0x004C(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	bool                                          bIsHLOD;                                           // 0x004D(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	bool                                          bBlockOnSlowLoading;                               // 0x004E(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_4F[0x1];                                       // 0x004F(0x0001)(Fixing Size After Last Property [ Dumper-7 ])
	struct FGuid                                  ContentBundleID;                                   // 0x0050(0x0010)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	struct FGuid                                  CellGuid;                                          // 0x0060(0x0010)(ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	struct FGuid                                  SourceCellGuid;                                    // 0x0070(0x0010)(ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	class UWorldPartitionRuntimeCellData*         RuntimeCellData;                                   // 0x0080(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"WorldPartitionRuntimeCell">();
	}
	static class UWorldPartitionRuntimeCell* GetDefaultObj()
	{
		return GetDefaultObjImpl<UWorldPartitionRuntimeCell>();
	}
};
static_assert(alignof(UWorldPartitionRuntimeCell) == 0x000008, "Wrong alignment on UWorldPartitionRuntimeCell");
static_assert(sizeof(UWorldPartitionRuntimeCell) == 0x000088, "Wrong size on UWorldPartitionRuntimeCell");
static_assert(offsetof(UWorldPartitionRuntimeCell, bIsAlwaysLoaded) == 0x000030, "Member 'UWorldPartitionRuntimeCell::bIsAlwaysLoaded' has a wrong offset!");
static_assert(offsetof(UWorldPartitionRuntimeCell, DataLayers) == 0x000038, "Member 'UWorldPartitionRuntimeCell::DataLayers' has a wrong offset!");
static_assert(offsetof(UWorldPartitionRuntimeCell, Priority) == 0x000048, "Member 'UWorldPartitionRuntimeCell::Priority' has a wrong offset!");
static_assert(offsetof(UWorldPartitionRuntimeCell, bClientOnlyVisible) == 0x00004C, "Member 'UWorldPartitionRuntimeCell::bClientOnlyVisible' has a wrong offset!");
static_assert(offsetof(UWorldPartitionRuntimeCell, bIsHLOD) == 0x00004D, "Member 'UWorldPartitionRuntimeCell::bIsHLOD' has a wrong offset!");
static_assert(offsetof(UWorldPartitionRuntimeCell, bBlockOnSlowLoading) == 0x00004E, "Member 'UWorldPartitionRuntimeCell::bBlockOnSlowLoading' has a wrong offset!");
static_assert(offsetof(UWorldPartitionRuntimeCell, ContentBundleID) == 0x000050, "Member 'UWorldPartitionRuntimeCell::ContentBundleID' has a wrong offset!");
static_assert(offsetof(UWorldPartitionRuntimeCell, CellGuid) == 0x000060, "Member 'UWorldPartitionRuntimeCell::CellGuid' has a wrong offset!");
static_assert(offsetof(UWorldPartitionRuntimeCell, SourceCellGuid) == 0x000070, "Member 'UWorldPartitionRuntimeCell::SourceCellGuid' has a wrong offset!");
static_assert(offsetof(UWorldPartitionRuntimeCell, RuntimeCellData) == 0x000080, "Member 'UWorldPartitionRuntimeCell::RuntimeCellData' has a wrong offset!");

// Class Engine.WorldPartitionRuntimeLevelStreamingCell
// 0x0008 (0x0090 - 0x0088)
class UWorldPartitionRuntimeLevelStreamingCell final : public UWorldPartitionRuntimeCell
{
public:
	class UWorldPartitionLevelStreamingDynamic*   LevelStreaming;                                    // 0x0088(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)

public:
	void OnLevelHidden();
	void OnLevelShown();

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"WorldPartitionRuntimeLevelStreamingCell">();
	}
	static class UWorldPartitionRuntimeLevelStreamingCell* GetDefaultObj()
	{
		return GetDefaultObjImpl<UWorldPartitionRuntimeLevelStreamingCell>();
	}
};
static_assert(alignof(UWorldPartitionRuntimeLevelStreamingCell) == 0x000008, "Wrong alignment on UWorldPartitionRuntimeLevelStreamingCell");
static_assert(sizeof(UWorldPartitionRuntimeLevelStreamingCell) == 0x000090, "Wrong size on UWorldPartitionRuntimeLevelStreamingCell");
static_assert(offsetof(UWorldPartitionRuntimeLevelStreamingCell, LevelStreaming) == 0x000088, "Member 'UWorldPartitionRuntimeLevelStreamingCell::LevelStreaming' has a wrong offset!");

// Class Engine.ParticleModuleVelocityInheritParent
// 0x0060 (0x0098 - 0x0038)
class UParticleModuleVelocityInheritParent final : public UParticleModuleVelocityBase
{
public:
	struct FRawDistributionVector                 Scale;                                             // 0x0038(0x0060)(Edit, ContainsInstancedReference, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ParticleModuleVelocityInheritParent">();
	}
	static class UParticleModuleVelocityInheritParent* GetDefaultObj()
	{
		return GetDefaultObjImpl<UParticleModuleVelocityInheritParent>();
	}
};
static_assert(alignof(UParticleModuleVelocityInheritParent) == 0x000008, "Wrong alignment on UParticleModuleVelocityInheritParent");
static_assert(sizeof(UParticleModuleVelocityInheritParent) == 0x000098, "Wrong size on UParticleModuleVelocityInheritParent");
static_assert(offsetof(UParticleModuleVelocityInheritParent, Scale) == 0x000038, "Member 'UParticleModuleVelocityInheritParent::Scale' has a wrong offset!");

// Class Engine.ParticleModuleVelocityOverLifetime
// 0x0068 (0x00A0 - 0x0038)
class UParticleModuleVelocityOverLifetime final : public UParticleModuleVelocityBase
{
public:
	struct FRawDistributionVector                 VelOverLife;                                       // 0x0038(0x0060)(Edit, ContainsInstancedReference, NativeAccessSpecifierPublic)
	uint8                                         Absolute : 1;                                      // 0x0098(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, ExportObject, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_99[0x7];                                       // 0x0099(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ParticleModuleVelocityOverLifetime">();
	}
	static class UParticleModuleVelocityOverLifetime* GetDefaultObj()
	{
		return GetDefaultObjImpl<UParticleModuleVelocityOverLifetime>();
	}
};
static_assert(alignof(UParticleModuleVelocityOverLifetime) == 0x000008, "Wrong alignment on UParticleModuleVelocityOverLifetime");
static_assert(sizeof(UParticleModuleVelocityOverLifetime) == 0x0000A0, "Wrong size on UParticleModuleVelocityOverLifetime");
static_assert(offsetof(UParticleModuleVelocityOverLifetime, VelOverLife) == 0x000038, "Member 'UParticleModuleVelocityOverLifetime::VelOverLife' has a wrong offset!");

// Class Engine.ParticleModuleVelocity_Seeded
// 0x0020 (0x00E8 - 0x00C8)
class UParticleModuleVelocity_Seeded final : public UParticleModuleVelocity
{
public:
	struct FParticleRandomSeedInfo                RandomSeedInfo;                                    // 0x00C8(0x0020)(Edit, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ParticleModuleVelocity_Seeded">();
	}
	static class UParticleModuleVelocity_Seeded* GetDefaultObj()
	{
		return GetDefaultObjImpl<UParticleModuleVelocity_Seeded>();
	}
};
static_assert(alignof(UParticleModuleVelocity_Seeded) == 0x000008, "Wrong alignment on UParticleModuleVelocity_Seeded");
static_assert(sizeof(UParticleModuleVelocity_Seeded) == 0x0000E8, "Wrong size on UParticleModuleVelocity_Seeded");
static_assert(offsetof(UParticleModuleVelocity_Seeded, RandomSeedInfo) == 0x0000C8, "Member 'UParticleModuleVelocity_Seeded::RandomSeedInfo' has a wrong offset!");

// Class Engine.ParticleSpriteEmitter
// 0x0000 (0x01C0 - 0x01C0)
class UParticleSpriteEmitter final : public UParticleEmitter
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ParticleSpriteEmitter">();
	}
	static class UParticleSpriteEmitter* GetDefaultObj()
	{
		return GetDefaultObjImpl<UParticleSpriteEmitter>();
	}
};
static_assert(alignof(UParticleSpriteEmitter) == 0x000008, "Wrong alignment on UParticleSpriteEmitter");
static_assert(sizeof(UParticleSpriteEmitter) == 0x0001C0, "Wrong size on UParticleSpriteEmitter");

// Class Engine.FXSystemComponent
// 0x0000 (0x0570 - 0x0570)
class UFXSystemComponent : public UPrimitiveComponent
{
public:
	void ReleaseToPool();
	void SetActorParameter(class FName ParameterName, class AActor* Param);
	void SetAutoAttachmentParameters(class USceneComponent* Parent, class FName SocketName, EAttachmentRule LocationRule, EAttachmentRule RotationRule, EAttachmentRule ScaleRule);
	void SetBoolParameter(class FName ParameterName, bool Param);
	void SetColorParameter(class FName ParameterName, const struct FLinearColor& Param);
	void SetEmitterEnable(class FName EmitterName, bool bNewEnableState);
	void SetFloatParameter(class FName ParameterName, float Param);
	void SetIntParameter(class FName ParameterName, int32 Param);
	void SetUseAutoManageAttachment(bool bAutoManage);
	void SetVectorParameter(class FName ParameterName, const struct FVector& Param);

	class UFXSystemAsset* GetFXSystemAsset() const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"FXSystemComponent">();
	}
	static class UFXSystemComponent* GetDefaultObj()
	{
		return GetDefaultObjImpl<UFXSystemComponent>();
	}
};
static_assert(alignof(UFXSystemComponent) == 0x000010, "Wrong alignment on UFXSystemComponent");
static_assert(sizeof(UFXSystemComponent) == 0x000570, "Wrong size on UFXSystemComponent");

// Class Engine.ParticleSystemComponent
// 0x0310 (0x0880 - 0x0570)
class UParticleSystemComponent final : public UFXSystemComponent
{
public:
	class UParticleSystem*                        Template;                                          // 0x0570(0x0008)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TArray<class UMaterialInterface*>             EmitterMaterials;                                  // 0x0578(0x0010)(ZeroConstructor, Transient, DuplicateTransient, UObjectWrapper, NativeAccessSpecifierPublic)
	TArray<class USkeletalMeshComponent*>         SkelMeshComponents;                                // 0x0588(0x0010)(ExportObject, ZeroConstructor, Transient, DuplicateTransient, ContainsInstancedReference, UObjectWrapper, NativeAccessSpecifierPublic)
	uint8                                         Pad_598[0x1];                                      // 0x0598(0x0001)(Fixing Size After Last Property [ Dumper-7 ])
	uint8                                         bResetOnDetach : 1;                                // 0x0599(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bUpdateOnDedicatedServer : 1;                      // 0x0599(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         BitPad_599_2 : 2;                                  // 0x0599(0x0001)(Fixing Bit-Field Size Between Bits [ Dumper-7 ])
	uint8                                         bAllowRecycling : 1;                               // 0x0599(0x0001)(BitIndex: 0x04, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bAutoManageAttachment : 1;                         // 0x0599(0x0001)(BitIndex: 0x05, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bAutoAttachWeldSimulatedBodies : 1;                // 0x0599(0x0001)(BitIndex: 0x06, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         BitPad_599_7 : 1;                                  // 0x0599(0x0001)(Fixing Bit-Field Size For New Byte [ Dumper-7 ])
	uint8                                         BitPad_59A_0 : 2;                                  // 0x059A(0x0001)(Fixing Bit-Field Size Between Bits [ Dumper-7 ])
	uint8                                         bWarmingUp : 1;                                    // 0x059A(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bOverrideLODMethod : 1;                            // 0x059A(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bSkipUpdateDynamicDataDuringTick : 1;              // 0x059A(0x0001)(BitIndex: 0x04, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_59B[0xA];                                      // 0x059B(0x000A)(Fixing Size After Last Property [ Dumper-7 ])
	EParticleSystemLODMethod                      LODMethod;                                         // 0x05A5(0x0001)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EParticleSignificanceLevel                    RequiredSignificance;                              // 0x05A6(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_5A7[0x1];                                      // 0x05A7(0x0001)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<struct FParticleSysParam>              InstanceParameters;                                // 0x05A8(0x0010)(Edit, BlueprintVisible, ZeroConstructor, NativeAccessSpecifierPublic)
	TMulticastInlineDelegate<void(class FName EventName, float EmitterTime, const struct FVector& Location, const struct FVector& Velocity)> OnParticleSpawn; // 0x05B8(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	TMulticastInlineDelegate<void(class FName EventName, float EmitterTime, int32 ParticleCount)> OnParticleBurst; // 0x05C8(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	TMulticastInlineDelegate<void(class FName EventName, float EmitterTime, int32 ParticleTime, const struct FVector& Location, const struct FVector& Velocity, const struct FVector& Direction)> OnParticleDeath; // 0x05D8(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	TMulticastInlineDelegate<void(class FName EventName, float EmitterTime, int32 ParticleTime, const struct FVector& Location, const struct FVector& Velocity, const struct FVector& Direction, const struct FVector& Normal, class FName BoneName, class UPhysicalMaterial* PhysMat)> OnParticleCollide; // 0x05E8(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	bool                                          bOldPositionValid;                                 // 0x05F8(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_5F9[0x7];                                      // 0x05F9(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	struct FVector                                OldPosition;                                       // 0x0600(0x0018)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector                                PartSysVelocity;                                   // 0x0618(0x0018)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         WarmupTime;                                        // 0x0630(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         WarmupTickRate;                                    // 0x0634(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_638[0x4];                                      // 0x0638(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         SecondsBeforeInactive;                             // 0x063C(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_640[0x4];                                      // 0x0640(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         MaxTimeBeforeForceUpdateTransform;                 // 0x0644(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_648[0x20];                                     // 0x0648(0x0020)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<class UParticleSystemReplay*>          ReplayClips;                                       // 0x0668(0x0010)(ZeroConstructor, UObjectWrapper, NativeAccessSpecifierPublic)
	uint8                                         Pad_678[0x8];                                      // 0x0678(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         CustomTimeDilation;                                // 0x0680(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_684[0x54];                                     // 0x0684(0x0054)(Fixing Size After Last Property [ Dumper-7 ])
	TWeakObjectPtr<class USceneComponent>         AutoAttachParent;                                  // 0x06D8(0x0008)(Edit, BlueprintVisible, ExportObject, ZeroConstructor, DisableEditOnTemplate, EditConst, InstancedReference, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FName                                   AutoAttachSocketName;                              // 0x06E0(0x0008)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EAttachmentRule                               AutoAttachLocationRule;                            // 0x06E8(0x0001)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EAttachmentRule                               AutoAttachRotationRule;                            // 0x06E9(0x0001)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EAttachmentRule                               AutoAttachScaleRule;                               // 0x06EA(0x0001)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_6EB[0x55];                                     // 0x06EB(0x0055)(Fixing Size After Last Property [ Dumper-7 ])
	TMulticastInlineDelegate<void(class UParticleSystemComponent* PSystem)> OnSystemFinished;        // 0x0740(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	uint8                                         Pad_750[0x130];                                    // 0x0750(0x0130)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void BeginTrails(class FName InFirstSocketName, class FName InSecondSocketName, ETrailWidthMode InWidthMode, float InWidth);
	class UMaterialInstanceDynamic* CreateNamedDynamicMaterialInstance(class FName InName, class UMaterialInterface* SourceMaterial);
	void EndTrails();
	void GenerateParticleEvent(const class FName InEventName, const float InEmitterTime, const struct FVector& InLocation, const struct FVector& InDirection, const struct FVector& InVelocity);
	void SetAutoAttachParams(class USceneComponent* Parent, class FName SocketName, EAttachLocation LocationType);
	void SetBeamEndPoint(int32 EmitterIndex, const struct FVector& NewEndPoint);
	void SetBeamSourcePoint(int32 EmitterIndex, const struct FVector& NewSourcePoint, int32 SourceIndex);
	void SetBeamSourceStrength(int32 EmitterIndex, float NewSourceStrength, int32 SourceIndex);
	void SetBeamSourceTangent(int32 EmitterIndex, const struct FVector& NewTangentPoint, int32 SourceIndex);
	void SetBeamTargetPoint(int32 EmitterIndex, const struct FVector& NewTargetPoint, int32 TargetIndex);
	void SetBeamTargetStrength(int32 EmitterIndex, float NewTargetStrength, int32 TargetIndex);
	void SetBeamTargetTangent(int32 EmitterIndex, const struct FVector& NewTangentPoint, int32 TargetIndex);
	void SetMaterialParameter(class FName ParameterName, class UMaterialInterface* Param);
	void SetTemplate(class UParticleSystem* NewTemplate);
	void SetTrailSourceData(class FName InFirstSocketName, class FName InSecondSocketName, ETrailWidthMode InWidthMode, float InWidth);

	bool GetBeamEndPoint(int32 EmitterIndex, struct FVector* OutEndPoint) const;
	bool GetBeamSourcePoint(int32 EmitterIndex, int32 SourceIndex, struct FVector* OutSourcePoint) const;
	bool GetBeamSourceStrength(int32 EmitterIndex, int32 SourceIndex, float* OutSourceStrength) const;
	bool GetBeamSourceTangent(int32 EmitterIndex, int32 SourceIndex, struct FVector* OutTangentPoint) const;
	bool GetBeamTargetPoint(int32 EmitterIndex, int32 TargetIndex, struct FVector* OutTargetPoint) const;
	bool GetBeamTargetStrength(int32 EmitterIndex, int32 TargetIndex, float* OutTargetStrength) const;
	bool GetBeamTargetTangent(int32 EmitterIndex, int32 TargetIndex, struct FVector* OutTangentPoint) const;
	class UMaterialInterface* GetNamedMaterial(class FName InName) const;
	int32 GetNumActiveParticles() const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ParticleSystemComponent">();
	}
	static class UParticleSystemComponent* GetDefaultObj()
	{
		return GetDefaultObjImpl<UParticleSystemComponent>();
	}
};
static_assert(alignof(UParticleSystemComponent) == 0x000010, "Wrong alignment on UParticleSystemComponent");
static_assert(sizeof(UParticleSystemComponent) == 0x000880, "Wrong size on UParticleSystemComponent");
static_assert(offsetof(UParticleSystemComponent, Template) == 0x000570, "Member 'UParticleSystemComponent::Template' has a wrong offset!");
static_assert(offsetof(UParticleSystemComponent, EmitterMaterials) == 0x000578, "Member 'UParticleSystemComponent::EmitterMaterials' has a wrong offset!");
static_assert(offsetof(UParticleSystemComponent, SkelMeshComponents) == 0x000588, "Member 'UParticleSystemComponent::SkelMeshComponents' has a wrong offset!");
static_assert(offsetof(UParticleSystemComponent, LODMethod) == 0x0005A5, "Member 'UParticleSystemComponent::LODMethod' has a wrong offset!");
static_assert(offsetof(UParticleSystemComponent, RequiredSignificance) == 0x0005A6, "Member 'UParticleSystemComponent::RequiredSignificance' has a wrong offset!");
static_assert(offsetof(UParticleSystemComponent, InstanceParameters) == 0x0005A8, "Member 'UParticleSystemComponent::InstanceParameters' has a wrong offset!");
static_assert(offsetof(UParticleSystemComponent, OnParticleSpawn) == 0x0005B8, "Member 'UParticleSystemComponent::OnParticleSpawn' has a wrong offset!");
static_assert(offsetof(UParticleSystemComponent, OnParticleBurst) == 0x0005C8, "Member 'UParticleSystemComponent::OnParticleBurst' has a wrong offset!");
static_assert(offsetof(UParticleSystemComponent, OnParticleDeath) == 0x0005D8, "Member 'UParticleSystemComponent::OnParticleDeath' has a wrong offset!");
static_assert(offsetof(UParticleSystemComponent, OnParticleCollide) == 0x0005E8, "Member 'UParticleSystemComponent::OnParticleCollide' has a wrong offset!");
static_assert(offsetof(UParticleSystemComponent, bOldPositionValid) == 0x0005F8, "Member 'UParticleSystemComponent::bOldPositionValid' has a wrong offset!");
static_assert(offsetof(UParticleSystemComponent, OldPosition) == 0x000600, "Member 'UParticleSystemComponent::OldPosition' has a wrong offset!");
static_assert(offsetof(UParticleSystemComponent, PartSysVelocity) == 0x000618, "Member 'UParticleSystemComponent::PartSysVelocity' has a wrong offset!");
static_assert(offsetof(UParticleSystemComponent, WarmupTime) == 0x000630, "Member 'UParticleSystemComponent::WarmupTime' has a wrong offset!");
static_assert(offsetof(UParticleSystemComponent, WarmupTickRate) == 0x000634, "Member 'UParticleSystemComponent::WarmupTickRate' has a wrong offset!");
static_assert(offsetof(UParticleSystemComponent, SecondsBeforeInactive) == 0x00063C, "Member 'UParticleSystemComponent::SecondsBeforeInactive' has a wrong offset!");
static_assert(offsetof(UParticleSystemComponent, MaxTimeBeforeForceUpdateTransform) == 0x000644, "Member 'UParticleSystemComponent::MaxTimeBeforeForceUpdateTransform' has a wrong offset!");
static_assert(offsetof(UParticleSystemComponent, ReplayClips) == 0x000668, "Member 'UParticleSystemComponent::ReplayClips' has a wrong offset!");
static_assert(offsetof(UParticleSystemComponent, CustomTimeDilation) == 0x000680, "Member 'UParticleSystemComponent::CustomTimeDilation' has a wrong offset!");
static_assert(offsetof(UParticleSystemComponent, AutoAttachParent) == 0x0006D8, "Member 'UParticleSystemComponent::AutoAttachParent' has a wrong offset!");
static_assert(offsetof(UParticleSystemComponent, AutoAttachSocketName) == 0x0006E0, "Member 'UParticleSystemComponent::AutoAttachSocketName' has a wrong offset!");
static_assert(offsetof(UParticleSystemComponent, AutoAttachLocationRule) == 0x0006E8, "Member 'UParticleSystemComponent::AutoAttachLocationRule' has a wrong offset!");
static_assert(offsetof(UParticleSystemComponent, AutoAttachRotationRule) == 0x0006E9, "Member 'UParticleSystemComponent::AutoAttachRotationRule' has a wrong offset!");
static_assert(offsetof(UParticleSystemComponent, AutoAttachScaleRule) == 0x0006EA, "Member 'UParticleSystemComponent::AutoAttachScaleRule' has a wrong offset!");
static_assert(offsetof(UParticleSystemComponent, OnSystemFinished) == 0x000740, "Member 'UParticleSystemComponent::OnSystemFinished' has a wrong offset!");

// Class Engine.ParticleSystemReplay
// 0x0018 (0x0040 - 0x0028)
class UParticleSystemReplay final : public UObject
{
public:
	int32                                         ClipIDNumber;                                      // 0x0028(0x0004)(Edit, ZeroConstructor, Transient, DuplicateTransient, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_2C[0x14];                                      // 0x002C(0x0014)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ParticleSystemReplay">();
	}
	static class UParticleSystemReplay* GetDefaultObj()
	{
		return GetDefaultObjImpl<UParticleSystemReplay>();
	}
};
static_assert(alignof(UParticleSystemReplay) == 0x000008, "Wrong alignment on UParticleSystemReplay");
static_assert(sizeof(UParticleSystemReplay) == 0x000040, "Wrong size on UParticleSystemReplay");
static_assert(offsetof(UParticleSystemReplay, ClipIDNumber) == 0x000028, "Member 'UParticleSystemReplay::ClipIDNumber' has a wrong offset!");

// Class Engine.PathFollowingAgentInterface
// 0x0000 (0x0000 - 0x0000)
class IPathFollowingAgentInterface final
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"PathFollowingAgentInterface">();
	}
	static class IPathFollowingAgentInterface* GetDefaultObj()
	{
		return GetDefaultObjImpl<IPathFollowingAgentInterface>();
	}

	class UObject* AsUObject()
	{
		return reinterpret_cast<UObject*>(this);
	}
	const class UObject* AsUObject() const
	{
		return reinterpret_cast<const UObject*>(this);
	}
};
static_assert(alignof(IPathFollowingAgentInterface) == 0x000001, "Wrong alignment on IPathFollowingAgentInterface");
static_assert(sizeof(IPathFollowingAgentInterface) == 0x000001, "Wrong size on IPathFollowingAgentInterface");

// Class Engine.ApplicationLifecycleComponent
// 0x0090 (0x0138 - 0x00A8)
class UApplicationLifecycleComponent final : public UActorComponent
{
public:
	TMulticastInlineDelegate<void()>              ApplicationWillDeactivateDelegate;                 // 0x00A8(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	TMulticastInlineDelegate<void()>              ApplicationHasReactivatedDelegate;                 // 0x00B8(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	TMulticastInlineDelegate<void()>              ApplicationWillEnterBackgroundDelegate;            // 0x00C8(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	TMulticastInlineDelegate<void()>              ApplicationHasEnteredForegroundDelegate;           // 0x00D8(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	TMulticastInlineDelegate<void()>              ApplicationWillTerminateDelegate;                  // 0x00E8(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	TMulticastInlineDelegate<void()>              ApplicationShouldUnloadResourcesDelegate;          // 0x00F8(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	TMulticastInlineDelegate<void(const TArray<class FString>& StartupArguments)> ApplicationReceivedStartupArgumentsDelegate; // 0x0108(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	TMulticastInlineDelegate<void(ETemperatureSeverityType Severity)> OnTemperatureChangeDelegate;   // 0x0118(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	TMulticastInlineDelegate<void(bool bInLowPowerMode)> OnLowPowerModeDelegate;                     // 0x0128(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ApplicationLifecycleComponent">();
	}
	static class UApplicationLifecycleComponent* GetDefaultObj()
	{
		return GetDefaultObjImpl<UApplicationLifecycleComponent>();
	}
};
static_assert(alignof(UApplicationLifecycleComponent) == 0x000008, "Wrong alignment on UApplicationLifecycleComponent");
static_assert(sizeof(UApplicationLifecycleComponent) == 0x000138, "Wrong size on UApplicationLifecycleComponent");
static_assert(offsetof(UApplicationLifecycleComponent, ApplicationWillDeactivateDelegate) == 0x0000A8, "Member 'UApplicationLifecycleComponent::ApplicationWillDeactivateDelegate' has a wrong offset!");
static_assert(offsetof(UApplicationLifecycleComponent, ApplicationHasReactivatedDelegate) == 0x0000B8, "Member 'UApplicationLifecycleComponent::ApplicationHasReactivatedDelegate' has a wrong offset!");
static_assert(offsetof(UApplicationLifecycleComponent, ApplicationWillEnterBackgroundDelegate) == 0x0000C8, "Member 'UApplicationLifecycleComponent::ApplicationWillEnterBackgroundDelegate' has a wrong offset!");
static_assert(offsetof(UApplicationLifecycleComponent, ApplicationHasEnteredForegroundDelegate) == 0x0000D8, "Member 'UApplicationLifecycleComponent::ApplicationHasEnteredForegroundDelegate' has a wrong offset!");
static_assert(offsetof(UApplicationLifecycleComponent, ApplicationWillTerminateDelegate) == 0x0000E8, "Member 'UApplicationLifecycleComponent::ApplicationWillTerminateDelegate' has a wrong offset!");
static_assert(offsetof(UApplicationLifecycleComponent, ApplicationShouldUnloadResourcesDelegate) == 0x0000F8, "Member 'UApplicationLifecycleComponent::ApplicationShouldUnloadResourcesDelegate' has a wrong offset!");
static_assert(offsetof(UApplicationLifecycleComponent, ApplicationReceivedStartupArgumentsDelegate) == 0x000108, "Member 'UApplicationLifecycleComponent::ApplicationReceivedStartupArgumentsDelegate' has a wrong offset!");
static_assert(offsetof(UApplicationLifecycleComponent, OnTemperatureChangeDelegate) == 0x000118, "Member 'UApplicationLifecycleComponent::OnTemperatureChangeDelegate' has a wrong offset!");
static_assert(offsetof(UApplicationLifecycleComponent, OnLowPowerModeDelegate) == 0x000128, "Member 'UApplicationLifecycleComponent::OnLowPowerModeDelegate' has a wrong offset!");

// Class Engine.PhysicsObjectBlueprintLibrary
// 0x0000 (0x0028 - 0x0028)
class UPhysicsObjectBlueprintLibrary final : public UBlueprintFunctionLibrary
{
public:
	static void ApplyRadialImpulse(class UPrimitiveComponent* Component, const struct FVector& Origin, float Radius, float Strength, ERadialImpulseFalloff Falloff, bool bApplyStrain);
	static bool ExtractClosestPhysicsObjectResults(const struct FClosestPhysicsObjectResult& Result, class FName* OutName);
	static struct FClosestPhysicsObjectResult GetClosestPhysicsObjectFromWorldLocation(class UPrimitiveComponent* Component, const struct FVector& WorldLocation);
	static struct FTransform GetPhysicsObjectWorldTransform(class UPrimitiveComponent* Component, class FName BoneName);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"PhysicsObjectBlueprintLibrary">();
	}
	static class UPhysicsObjectBlueprintLibrary* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPhysicsObjectBlueprintLibrary>();
	}
};
static_assert(alignof(UPhysicsObjectBlueprintLibrary) == 0x000008, "Wrong alignment on UPhysicsObjectBlueprintLibrary");
static_assert(sizeof(UPhysicsObjectBlueprintLibrary) == 0x000028, "Wrong size on UPhysicsObjectBlueprintLibrary");

// Class Engine.PhysicsSpringComponent
// 0x0030 (0x02D0 - 0x02A0)
class UPhysicsSpringComponent final : public USceneComponent
{
public:
	float                                         SpringStiffness;                                   // 0x02A0(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         SpringDamping;                                     // 0x02A4(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         SpringLengthAtRest;                                // 0x02A8(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         SpringRadius;                                      // 0x02AC(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	ECollisionChannel                             SpringChannel;                                     // 0x02B0(0x0001)(BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bIgnoreSelf;                                       // 0x02B1(0x0001)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_2B2[0x2];                                      // 0x02B2(0x0002)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         SpringCompression;                                 // 0x02B4(0x0004)(BlueprintVisible, BlueprintReadOnly, ZeroConstructor, Transient, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_2B8[0x18];                                     // 0x02B8(0x0018)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	float GetNormalizedCompressionScalar() const;
	struct FVector GetSpringCurrentEndPoint() const;
	struct FVector GetSpringDirection() const;
	struct FVector GetSpringRestingPoint() const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"PhysicsSpringComponent">();
	}
	static class UPhysicsSpringComponent* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPhysicsSpringComponent>();
	}
};
static_assert(alignof(UPhysicsSpringComponent) == 0x000010, "Wrong alignment on UPhysicsSpringComponent");
static_assert(sizeof(UPhysicsSpringComponent) == 0x0002D0, "Wrong size on UPhysicsSpringComponent");
static_assert(offsetof(UPhysicsSpringComponent, SpringStiffness) == 0x0002A0, "Member 'UPhysicsSpringComponent::SpringStiffness' has a wrong offset!");
static_assert(offsetof(UPhysicsSpringComponent, SpringDamping) == 0x0002A4, "Member 'UPhysicsSpringComponent::SpringDamping' has a wrong offset!");
static_assert(offsetof(UPhysicsSpringComponent, SpringLengthAtRest) == 0x0002A8, "Member 'UPhysicsSpringComponent::SpringLengthAtRest' has a wrong offset!");
static_assert(offsetof(UPhysicsSpringComponent, SpringRadius) == 0x0002AC, "Member 'UPhysicsSpringComponent::SpringRadius' has a wrong offset!");
static_assert(offsetof(UPhysicsSpringComponent, SpringChannel) == 0x0002B0, "Member 'UPhysicsSpringComponent::SpringChannel' has a wrong offset!");
static_assert(offsetof(UPhysicsSpringComponent, bIgnoreSelf) == 0x0002B1, "Member 'UPhysicsSpringComponent::bIgnoreSelf' has a wrong offset!");
static_assert(offsetof(UPhysicsSpringComponent, SpringCompression) == 0x0002B4, "Member 'UPhysicsSpringComponent::SpringCompression' has a wrong offset!");

// Class Engine.PhysicsThreadLibrary
// 0x0000 (0x0028 - 0x0028)
class UPhysicsThreadLibrary final : public UBlueprintFunctionLibrary
{
public:
	static void AddForce(const struct FBodyInstanceAsyncPhysicsTickHandle& Handle, const struct FVector& Force, bool bAccelChange);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"PhysicsThreadLibrary">();
	}
	static class UPhysicsThreadLibrary* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPhysicsThreadLibrary>();
	}
};
static_assert(alignof(UPhysicsThreadLibrary) == 0x000008, "Wrong alignment on UPhysicsThreadLibrary");
static_assert(sizeof(UPhysicsThreadLibrary) == 0x000028, "Wrong size on UPhysicsThreadLibrary");

// Class Engine.PhysicsThrusterComponent
// 0x0010 (0x02B0 - 0x02A0)
class UPhysicsThrusterComponent final : public USceneComponent
{
public:
	float                                         ThrustStrength;                                    // 0x02A0(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_2A4[0xC];                                      // 0x02A4(0x000C)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"PhysicsThrusterComponent">();
	}
	static class UPhysicsThrusterComponent* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPhysicsThrusterComponent>();
	}
};
static_assert(alignof(UPhysicsThrusterComponent) == 0x000010, "Wrong alignment on UPhysicsThrusterComponent");
static_assert(sizeof(UPhysicsThrusterComponent) == 0x0002B0, "Wrong size on UPhysicsThrusterComponent");
static_assert(offsetof(UPhysicsThrusterComponent, ThrustStrength) == 0x0002A0, "Member 'UPhysicsThrusterComponent::ThrustStrength' has a wrong offset!");

// Class Engine.BillboardComponent
// 0x0030 (0x05A0 - 0x0570)
class UBillboardComponent final : public UPrimitiveComponent
{
public:
	class UTexture2D*                             Sprite;                                            // 0x0570(0x0008)(Edit, BlueprintVisible, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bIsScreenSizeScaled : 1;                           // 0x0578(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_579[0x3];                                      // 0x0579(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         ScreenSize;                                        // 0x057C(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         U;                                                 // 0x0580(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         UL;                                                // 0x0584(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         V;                                                 // 0x0588(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         VL;                                                // 0x058C(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         OpacityMaskRefVal;                                 // 0x0590(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_594[0xC];                                      // 0x0594(0x000C)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void SetOpacityMaskRefVal(float RefVal);
	void SetSprite(class UTexture2D* NewSprite);
	void SetSpriteAndUV(class UTexture2D* NewSprite, int32 NewU, int32 NewUL, int32 NewV, int32 NewVL);
	void SetUV(int32 NewU, int32 NewUL, int32 NewV, int32 NewVL);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"BillboardComponent">();
	}
	static class UBillboardComponent* GetDefaultObj()
	{
		return GetDefaultObjImpl<UBillboardComponent>();
	}
};
static_assert(alignof(UBillboardComponent) == 0x000010, "Wrong alignment on UBillboardComponent");
static_assert(sizeof(UBillboardComponent) == 0x0005A0, "Wrong size on UBillboardComponent");
static_assert(offsetof(UBillboardComponent, Sprite) == 0x000570, "Member 'UBillboardComponent::Sprite' has a wrong offset!");
static_assert(offsetof(UBillboardComponent, ScreenSize) == 0x00057C, "Member 'UBillboardComponent::ScreenSize' has a wrong offset!");
static_assert(offsetof(UBillboardComponent, U) == 0x000580, "Member 'UBillboardComponent::U' has a wrong offset!");
static_assert(offsetof(UBillboardComponent, UL) == 0x000584, "Member 'UBillboardComponent::UL' has a wrong offset!");
static_assert(offsetof(UBillboardComponent, V) == 0x000588, "Member 'UBillboardComponent::V' has a wrong offset!");
static_assert(offsetof(UBillboardComponent, VL) == 0x00058C, "Member 'UBillboardComponent::VL' has a wrong offset!");
static_assert(offsetof(UBillboardComponent, OpacityMaskRefVal) == 0x000590, "Member 'UBillboardComponent::OpacityMaskRefVal' has a wrong offset!");

// Class Engine.PieFixupTestObject
// 0x00A0 (0x00C8 - 0x0028)
class UPieFixupTestObject final : public UObject
{
public:
	struct FSoftObjectPath                        Path;                                              // 0x0028(0x0020)(ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TSoftObjectPtr<class AActor>                  TypedPtr;                                          // 0x0048(0x0028)(UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FPieFixupStructWithSoftObjectPath      Struct;                                            // 0x0070(0x0048)(NativeAccessSpecifierPublic)
	TArray<struct FPieFixupStructWithSoftObjectPath> Array;                                          // 0x00B8(0x0010)(ZeroConstructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"PieFixupTestObject">();
	}
	static class UPieFixupTestObject* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPieFixupTestObject>();
	}
};
static_assert(alignof(UPieFixupTestObject) == 0x000008, "Wrong alignment on UPieFixupTestObject");
static_assert(sizeof(UPieFixupTestObject) == 0x0000C8, "Wrong size on UPieFixupTestObject");
static_assert(offsetof(UPieFixupTestObject, Path) == 0x000028, "Member 'UPieFixupTestObject::Path' has a wrong offset!");
static_assert(offsetof(UPieFixupTestObject, TypedPtr) == 0x000048, "Member 'UPieFixupTestObject::TypedPtr' has a wrong offset!");
static_assert(offsetof(UPieFixupTestObject, Struct) == 0x000070, "Member 'UPieFixupTestObject::Struct' has a wrong offset!");
static_assert(offsetof(UPieFixupTestObject, Array) == 0x0000B8, "Member 'UPieFixupTestObject::Array' has a wrong offset!");

// Class Engine.SceneCapture
// 0x0010 (0x02B0 - 0x02A0)
class ASceneCapture : public AActor
{
public:
	class UStaticMeshComponent*                   meshComp;                                          // 0x02A0(0x0008)(ExportObject, ZeroConstructor, InstancedReference, Deprecated, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	class USceneComponent*                        SceneComponent;                                    // 0x02A8(0x0008)(Edit, BlueprintVisible, ExportObject, BlueprintReadOnly, ZeroConstructor, EditConst, InstancedReference, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"SceneCapture">();
	}
	static class ASceneCapture* GetDefaultObj()
	{
		return GetDefaultObjImpl<ASceneCapture>();
	}
};
static_assert(alignof(ASceneCapture) == 0x000008, "Wrong alignment on ASceneCapture");
static_assert(sizeof(ASceneCapture) == 0x0002B0, "Wrong size on ASceneCapture");
static_assert(offsetof(ASceneCapture, meshComp) == 0x0002A0, "Member 'ASceneCapture::meshComp' has a wrong offset!");
static_assert(offsetof(ASceneCapture, SceneComponent) == 0x0002A8, "Member 'ASceneCapture::SceneComponent' has a wrong offset!");

// Class Engine.PlanarReflection
// 0x0010 (0x02C0 - 0x02B0)
class APlanarReflection final : public ASceneCapture
{
public:
	class UPlanarReflectionComponent*             PlanarReflectionComponent;                         // 0x02B0(0x0008)(Edit, BlueprintVisible, ExportObject, BlueprintReadOnly, ZeroConstructor, EditConst, InstancedReference, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	bool                                          bShowPreviewPlane;                                 // 0x02B8(0x0001)(ZeroConstructor, Deprecated, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_2B9[0x7];                                      // 0x02B9(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void OnInterpToggle(bool bEnable);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"PlanarReflection">();
	}
	static class APlanarReflection* GetDefaultObj()
	{
		return GetDefaultObjImpl<APlanarReflection>();
	}
};
static_assert(alignof(APlanarReflection) == 0x000008, "Wrong alignment on APlanarReflection");
static_assert(sizeof(APlanarReflection) == 0x0002C0, "Wrong size on APlanarReflection");
static_assert(offsetof(APlanarReflection, PlanarReflectionComponent) == 0x0002B0, "Member 'APlanarReflection::PlanarReflectionComponent' has a wrong offset!");
static_assert(offsetof(APlanarReflection, bShowPreviewPlane) == 0x0002B8, "Member 'APlanarReflection::bShowPreviewPlane' has a wrong offset!");

// Class Engine.SceneCaptureComponent
// 0x00C0 (0x0360 - 0x02A0)
#pragma pack(push, 0x1)
class alignas(0x10) USceneCaptureComponent : public USceneComponent
{
public:
	ESceneCapturePrimitiveRenderMode              PrimitiveRenderMode;                               // 0x02A0(0x0001)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	ESceneCaptureSource                           CaptureSource;                                     // 0x02A1(0x0001)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bCaptureEveryFrame : 1;                            // 0x02A2(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bCaptureOnMovement : 1;                            // 0x02A2(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	bool                                          bAlwaysPersistRenderingState;                      // 0x02A3(0x0001)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_2A4[0x4];                                      // 0x02A4(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<TWeakObjectPtr<class UPrimitiveComponent>> HiddenComponents;                              // 0x02A8(0x0010)(ExportObject, ZeroConstructor, ContainsInstancedReference, UObjectWrapper, NativeAccessSpecifierPublic)
	TArray<class AActor*>                         HiddenActors;                                      // 0x02B8(0x0010)(Edit, BlueprintVisible, ZeroConstructor, DisableEditOnTemplate, UObjectWrapper, NativeAccessSpecifierPublic)
	TArray<TWeakObjectPtr<class UPrimitiveComponent>> ShowOnlyComponents;                            // 0x02C8(0x0010)(ExportObject, ZeroConstructor, ContainsInstancedReference, UObjectWrapper, NativeAccessSpecifierPublic)
	TArray<class AActor*>                         ShowOnlyActors;                                    // 0x02D8(0x0010)(Edit, BlueprintVisible, ZeroConstructor, DisableEditOnTemplate, UObjectWrapper, NativeAccessSpecifierPublic)
	float                                         LODDistanceFactor;                                 // 0x02E8(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         MaxViewDistanceOverride;                           // 0x02EC(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         CaptureSortPriority;                               // 0x02F0(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bUseRayTracingIfEnabled;                           // 0x02F4(0x0001)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_2F5[0x3];                                      // 0x02F5(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<struct FEngineShowFlagsSetting>        ShowFlagSettings;                                  // 0x02F8(0x0010)(Edit, BlueprintVisible, ZeroConstructor, Interp, NativeAccessSpecifierPublic)
	uint8                                         Pad_308[0x30];                                     // 0x0308(0x0030)(Fixing Size After Last Property [ Dumper-7 ])
	class FString                                 ProfilingEventName;                                // 0x0338(0x0010)(Edit, BlueprintVisible, ZeroConstructor, Interp, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_348[0x10];                                     // 0x0348(0x0010)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void ClearHiddenComponents();
	void ClearShowOnlyComponents();
	void HideActorComponents(class AActor* InActor, const bool bIncludeFromChildActors);
	void HideComponent(class UPrimitiveComponent* InComponent);
	void RemoveShowOnlyActorComponents(class AActor* InActor, const bool bIncludeFromChildActors);
	void RemoveShowOnlyComponent(class UPrimitiveComponent* InComponent);
	void SetCaptureSortPriority(int32 NewCaptureSortPriority);
	void ShowOnlyActorComponents(class AActor* InActor, const bool bIncludeFromChildActors);
	void ShowOnlyComponent(class UPrimitiveComponent* InComponent);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"SceneCaptureComponent">();
	}
	static class USceneCaptureComponent* GetDefaultObj()
	{
		return GetDefaultObjImpl<USceneCaptureComponent>();
	}
};
#pragma pack(pop)
static_assert(alignof(USceneCaptureComponent) == 0x000010, "Wrong alignment on USceneCaptureComponent");
static_assert(sizeof(USceneCaptureComponent) == 0x000360, "Wrong size on USceneCaptureComponent");
static_assert(offsetof(USceneCaptureComponent, PrimitiveRenderMode) == 0x0002A0, "Member 'USceneCaptureComponent::PrimitiveRenderMode' has a wrong offset!");
static_assert(offsetof(USceneCaptureComponent, CaptureSource) == 0x0002A1, "Member 'USceneCaptureComponent::CaptureSource' has a wrong offset!");
static_assert(offsetof(USceneCaptureComponent, bAlwaysPersistRenderingState) == 0x0002A3, "Member 'USceneCaptureComponent::bAlwaysPersistRenderingState' has a wrong offset!");
static_assert(offsetof(USceneCaptureComponent, HiddenComponents) == 0x0002A8, "Member 'USceneCaptureComponent::HiddenComponents' has a wrong offset!");
static_assert(offsetof(USceneCaptureComponent, HiddenActors) == 0x0002B8, "Member 'USceneCaptureComponent::HiddenActors' has a wrong offset!");
static_assert(offsetof(USceneCaptureComponent, ShowOnlyComponents) == 0x0002C8, "Member 'USceneCaptureComponent::ShowOnlyComponents' has a wrong offset!");
static_assert(offsetof(USceneCaptureComponent, ShowOnlyActors) == 0x0002D8, "Member 'USceneCaptureComponent::ShowOnlyActors' has a wrong offset!");
static_assert(offsetof(USceneCaptureComponent, LODDistanceFactor) == 0x0002E8, "Member 'USceneCaptureComponent::LODDistanceFactor' has a wrong offset!");
static_assert(offsetof(USceneCaptureComponent, MaxViewDistanceOverride) == 0x0002EC, "Member 'USceneCaptureComponent::MaxViewDistanceOverride' has a wrong offset!");
static_assert(offsetof(USceneCaptureComponent, CaptureSortPriority) == 0x0002F0, "Member 'USceneCaptureComponent::CaptureSortPriority' has a wrong offset!");
static_assert(offsetof(USceneCaptureComponent, bUseRayTracingIfEnabled) == 0x0002F4, "Member 'USceneCaptureComponent::bUseRayTracingIfEnabled' has a wrong offset!");
static_assert(offsetof(USceneCaptureComponent, ShowFlagSettings) == 0x0002F8, "Member 'USceneCaptureComponent::ShowFlagSettings' has a wrong offset!");
static_assert(offsetof(USceneCaptureComponent, ProfilingEventName) == 0x000338, "Member 'USceneCaptureComponent::ProfilingEventName' has a wrong offset!");

// Class Engine.BrushComponent
// 0x0010 (0x0580 - 0x0570)
class UBrushComponent final : public UPrimitiveComponent
{
public:
	class UModel*                                 Brush;                                             // 0x0570(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UBodySetup*                             BrushBodySetup;                                    // 0x0578(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"BrushComponent">();
	}
	static class UBrushComponent* GetDefaultObj()
	{
		return GetDefaultObjImpl<UBrushComponent>();
	}
};
static_assert(alignof(UBrushComponent) == 0x000010, "Wrong alignment on UBrushComponent");
static_assert(sizeof(UBrushComponent) == 0x000580, "Wrong size on UBrushComponent");
static_assert(offsetof(UBrushComponent, Brush) == 0x000570, "Member 'UBrushComponent::Brush' has a wrong offset!");
static_assert(offsetof(UBrushComponent, BrushBodySetup) == 0x000578, "Member 'UBrushComponent::BrushBodySetup' has a wrong offset!");

// Class Engine.PlanarReflectionComponent
// 0x0160 (0x04C0 - 0x0360)
class UPlanarReflectionComponent final : public USceneCaptureComponent
{
public:
	class UBoxComponent*                          PreviewBox;                                        // 0x0358(0x0008)(ExportObject, ZeroConstructor, InstancedReference, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         NormalDistortionStrength;                          // 0x0360(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         PrefilterRoughness;                                // 0x0364(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         PrefilterRoughnessDistance;                        // 0x0368(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         ScreenPercentage;                                  // 0x036C(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         ExtraFOV;                                          // 0x0370(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         DistanceFromPlaneFadeStart;                        // 0x0374(0x0004)(ZeroConstructor, Deprecated, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         DistanceFromPlaneFadeEnd;                          // 0x0378(0x0004)(ZeroConstructor, Deprecated, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         DistanceFromPlaneFadeoutStart;                     // 0x037C(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         DistanceFromPlaneFadeoutEnd;                       // 0x0380(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         AngleFromPlaneFadeStart;                           // 0x0384(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         AngleFromPlaneFadeEnd;                             // 0x0388(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bShowPreviewPlane;                                 // 0x038C(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bRenderSceneTwoSided;                              // 0x038D(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_38E[0x132];                                    // 0x038E(0x0132)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"PlanarReflectionComponent">();
	}
	static class UPlanarReflectionComponent* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPlanarReflectionComponent>();
	}
};
static_assert(alignof(UPlanarReflectionComponent) == 0x000010, "Wrong alignment on UPlanarReflectionComponent");
static_assert(sizeof(UPlanarReflectionComponent) == 0x0004C0, "Wrong size on UPlanarReflectionComponent");
static_assert(offsetof(UPlanarReflectionComponent, PreviewBox) == 0x000358, "Member 'UPlanarReflectionComponent::PreviewBox' has a wrong offset!");
static_assert(offsetof(UPlanarReflectionComponent, NormalDistortionStrength) == 0x000360, "Member 'UPlanarReflectionComponent::NormalDistortionStrength' has a wrong offset!");
static_assert(offsetof(UPlanarReflectionComponent, PrefilterRoughness) == 0x000364, "Member 'UPlanarReflectionComponent::PrefilterRoughness' has a wrong offset!");
static_assert(offsetof(UPlanarReflectionComponent, PrefilterRoughnessDistance) == 0x000368, "Member 'UPlanarReflectionComponent::PrefilterRoughnessDistance' has a wrong offset!");
static_assert(offsetof(UPlanarReflectionComponent, ScreenPercentage) == 0x00036C, "Member 'UPlanarReflectionComponent::ScreenPercentage' has a wrong offset!");
static_assert(offsetof(UPlanarReflectionComponent, ExtraFOV) == 0x000370, "Member 'UPlanarReflectionComponent::ExtraFOV' has a wrong offset!");
static_assert(offsetof(UPlanarReflectionComponent, DistanceFromPlaneFadeStart) == 0x000374, "Member 'UPlanarReflectionComponent::DistanceFromPlaneFadeStart' has a wrong offset!");
static_assert(offsetof(UPlanarReflectionComponent, DistanceFromPlaneFadeEnd) == 0x000378, "Member 'UPlanarReflectionComponent::DistanceFromPlaneFadeEnd' has a wrong offset!");
static_assert(offsetof(UPlanarReflectionComponent, DistanceFromPlaneFadeoutStart) == 0x00037C, "Member 'UPlanarReflectionComponent::DistanceFromPlaneFadeoutStart' has a wrong offset!");
static_assert(offsetof(UPlanarReflectionComponent, DistanceFromPlaneFadeoutEnd) == 0x000380, "Member 'UPlanarReflectionComponent::DistanceFromPlaneFadeoutEnd' has a wrong offset!");
static_assert(offsetof(UPlanarReflectionComponent, AngleFromPlaneFadeStart) == 0x000384, "Member 'UPlanarReflectionComponent::AngleFromPlaneFadeStart' has a wrong offset!");
static_assert(offsetof(UPlanarReflectionComponent, AngleFromPlaneFadeEnd) == 0x000388, "Member 'UPlanarReflectionComponent::AngleFromPlaneFadeEnd' has a wrong offset!");
static_assert(offsetof(UPlanarReflectionComponent, bShowPreviewPlane) == 0x00038C, "Member 'UPlanarReflectionComponent::bShowPreviewPlane' has a wrong offset!");
static_assert(offsetof(UPlanarReflectionComponent, bRenderSceneTwoSided) == 0x00038D, "Member 'UPlanarReflectionComponent::bRenderSceneTwoSided' has a wrong offset!");

// Class Engine.PlaneReflectionCapture
// 0x0000 (0x02A8 - 0x02A8)
class APlaneReflectionCapture final : public AReflectionCapture
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"PlaneReflectionCapture">();
	}
	static class APlaneReflectionCapture* GetDefaultObj()
	{
		return GetDefaultObjImpl<APlaneReflectionCapture>();
	}
};
static_assert(alignof(APlaneReflectionCapture) == 0x000008, "Wrong alignment on APlaneReflectionCapture");
static_assert(sizeof(APlaneReflectionCapture) == 0x0002A8, "Wrong size on APlaneReflectionCapture");

// Class Engine.PlaneReflectionCaptureComponent
// 0x0020 (0x0330 - 0x0310)
class UPlaneReflectionCaptureComponent final : public UReflectionCaptureComponent
{
public:
	float                                         InfluenceRadiusScale;                              // 0x0310(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_314[0x4];                                      // 0x0314(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	class UDrawSphereComponent*                   PreviewInfluenceRadius;                            // 0x0318(0x0008)(ExportObject, ZeroConstructor, InstancedReference, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UBoxComponent*                          PreviewCaptureBox;                                 // 0x0320(0x0008)(ExportObject, ZeroConstructor, InstancedReference, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_328[0x8];                                      // 0x0328(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"PlaneReflectionCaptureComponent">();
	}
	static class UPlaneReflectionCaptureComponent* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPlaneReflectionCaptureComponent>();
	}
};
static_assert(alignof(UPlaneReflectionCaptureComponent) == 0x000010, "Wrong alignment on UPlaneReflectionCaptureComponent");
static_assert(sizeof(UPlaneReflectionCaptureComponent) == 0x000330, "Wrong size on UPlaneReflectionCaptureComponent");
static_assert(offsetof(UPlaneReflectionCaptureComponent, InfluenceRadiusScale) == 0x000310, "Member 'UPlaneReflectionCaptureComponent::InfluenceRadiusScale' has a wrong offset!");
static_assert(offsetof(UPlaneReflectionCaptureComponent, PreviewInfluenceRadius) == 0x000318, "Member 'UPlaneReflectionCaptureComponent::PreviewInfluenceRadius' has a wrong offset!");
static_assert(offsetof(UPlaneReflectionCaptureComponent, PreviewCaptureBox) == 0x000320, "Member 'UPlaneReflectionCaptureComponent::PreviewCaptureBox' has a wrong offset!");

// Class Engine.PlatformInterfaceWebResponse
// 0x0088 (0x00B0 - 0x0028)
class UPlatformInterfaceWebResponse final : public UObject
{
public:
	class FString                                 OriginalURL;                                       // 0x0028(0x0010)(ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         ResponseCode;                                      // 0x0038(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         Tag;                                               // 0x003C(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FString                                 StringResponse;                                    // 0x0040(0x0010)(ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TArray<uint8>                                 BinaryResponse;                                    // 0x0050(0x0010)(ZeroConstructor, NativeAccessSpecifierPublic)
	uint8                                         Pad_60[0x50];                                      // 0x0060(0x0050)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void GetHeader(int32 HeaderIndex, class FString* Header, class FString* Value);
	class FString GetHeaderValue(const class FString& HeaderName);
	int32 GetNumHeaders();

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"PlatformInterfaceWebResponse">();
	}
	static class UPlatformInterfaceWebResponse* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPlatformInterfaceWebResponse>();
	}
};
static_assert(alignof(UPlatformInterfaceWebResponse) == 0x000008, "Wrong alignment on UPlatformInterfaceWebResponse");
static_assert(sizeof(UPlatformInterfaceWebResponse) == 0x0000B0, "Wrong size on UPlatformInterfaceWebResponse");
static_assert(offsetof(UPlatformInterfaceWebResponse, OriginalURL) == 0x000028, "Member 'UPlatformInterfaceWebResponse::OriginalURL' has a wrong offset!");
static_assert(offsetof(UPlatformInterfaceWebResponse, ResponseCode) == 0x000038, "Member 'UPlatformInterfaceWebResponse::ResponseCode' has a wrong offset!");
static_assert(offsetof(UPlatformInterfaceWebResponse, Tag) == 0x00003C, "Member 'UPlatformInterfaceWebResponse::Tag' has a wrong offset!");
static_assert(offsetof(UPlatformInterfaceWebResponse, StringResponse) == 0x000040, "Member 'UPlatformInterfaceWebResponse::StringResponse' has a wrong offset!");
static_assert(offsetof(UPlatformInterfaceWebResponse, BinaryResponse) == 0x000050, "Member 'UPlatformInterfaceWebResponse::BinaryResponse' has a wrong offset!");

// Class Engine.PreviewCollectionInterface
// 0x0000 (0x0000 - 0x0000)
class IPreviewCollectionInterface final
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"PreviewCollectionInterface">();
	}
	static class IPreviewCollectionInterface* GetDefaultObj()
	{
		return GetDefaultObjImpl<IPreviewCollectionInterface>();
	}

	class UObject* AsUObject()
	{
		return reinterpret_cast<UObject*>(this);
	}
	const class UObject* AsUObject() const
	{
		return reinterpret_cast<const UObject*>(this);
	}
};
static_assert(alignof(IPreviewCollectionInterface) == 0x000001, "Wrong alignment on IPreviewCollectionInterface");
static_assert(sizeof(IPreviewCollectionInterface) == 0x000001, "Wrong size on IPreviewCollectionInterface");

// Class Engine.PlayerCameraManager
// 0x2160 (0x2400 - 0x02A0)
class APlayerCameraManager : public AActor
{
public:
	class APlayerController*                      PCOwner;                                           // 0x02A0(0x0008)(ZeroConstructor, Transient, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class USceneComponent*                        TransformComponent;                                // 0x02A8(0x0008)(Edit, BlueprintVisible, ExportObject, BlueprintReadOnly, ZeroConstructor, EditConst, InstancedReference, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_2B0[0x8];                                      // 0x02B0(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         DefaultFOV;                                        // 0x02B8(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_2BC[0x4];                                      // 0x02BC(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         DefaultOrthoWidth;                                 // 0x02C0(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_2C4[0x4];                                      // 0x02C4(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         DefaultAspectRatio;                                // 0x02C8(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_2CC[0x64];                                     // 0x02CC(0x0064)(Fixing Size After Last Property [ Dumper-7 ])
	struct FTViewTarget                           ViewTarget;                                        // 0x0330(0x07F0)(Transient, NativeAccessSpecifierPublic)
	struct FTViewTarget                           PendingViewTarget;                                 // 0x0B20(0x07F0)(Transient, NativeAccessSpecifierPublic)
	uint8                                         Pad_1310[0x30];                                    // 0x1310(0x0030)(Fixing Size After Last Property [ Dumper-7 ])
	struct FCameraCacheEntry                      CameraCachePrivate;                                // 0x1340(0x07E0)(Transient, NativeAccessSpecifierPrivate)
	struct FCameraCacheEntry                      LastFrameCameraCachePrivate;                       // 0x1B20(0x07E0)(Transient, NativeAccessSpecifierPrivate)
	TArray<class UCameraModifier*>                ModifierList;                                      // 0x2300(0x0010)(ZeroConstructor, Transient, Protected, UObjectWrapper, NativeAccessSpecifierProtected)
	TArray<TSubclassOf<class UCameraModifier>>    DefaultModifiers;                                  // 0x2310(0x0010)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, DisableEditOnInstance, UObjectWrapper, NativeAccessSpecifierPublic)
	float                                         FreeCamDistance;                                   // 0x2320(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_2324[0x4];                                     // 0x2324(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	struct FVector                                FreeCamOffset;                                     // 0x2328(0x0018)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector                                ViewTargetOffset;                                  // 0x2340(0x0018)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TMulticastInlineDelegate<void(bool bFadeOut, float FadeTime)> OnAudioFadeChangeEvent;            // 0x2358(0x0010)(ZeroConstructor, Transient, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	uint8                                         Pad_2368[0x18];                                    // 0x2368(0x0018)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<TScriptInterface<class ICameraLensEffectInterface>> CameraLensEffects;                    // 0x2380(0x0010)(ZeroConstructor, Transient, Protected, UObjectWrapper, NativeAccessSpecifierProtected)
	class UCameraModifier_CameraShake*            CachedCameraShakeMod;                              // 0x2390(0x0008)(ZeroConstructor, Transient, NoDestructor, Protected, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	TArray<struct FPostProcessSettings>           PostProcessBlendCache;                             // 0x2398(0x0010)(ZeroConstructor, Transient, Protected, NativeAccessSpecifierProtected)
	uint8                                         Pad_23A8[0x20];                                    // 0x23A8(0x0020)(Fixing Size After Last Property [ Dumper-7 ])
	class ACameraActor*                           AnimCameraActor;                                   // 0x23C8(0x0008)(ZeroConstructor, Transient, NoDestructor, Protected, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         bIsOrthographic : 1;                               // 0x23D0(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bDefaultConstrainAspectRatio : 1;                  // 0x23D0(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         BitPad_23D0_2 : 4;                                 // 0x23D0(0x0001)(Fixing Bit-Field Size Between Bits [ Dumper-7 ])
	uint8                                         bClientSimulatingViewTarget : 1;                   // 0x23D0(0x0001)(BitIndex: 0x06, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bUseClientSideCameraUpdates : 1;                   // 0x23D0(0x0001)(BitIndex: 0x07, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         BitPad_23D1_0 : 2;                                 // 0x23D1(0x0001)(Fixing Bit-Field Size Between Bits [ Dumper-7 ])
	uint8                                         bGameCameraCutThisFrame : 1;                       // 0x23D1(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (BlueprintVisible, BlueprintReadOnly, Transient, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_23D2[0x2];                                     // 0x23D2(0x0002)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         ViewPitchMin;                                      // 0x23D4(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         ViewPitchMax;                                      // 0x23D8(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         ViewYawMin;                                        // 0x23DC(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         ViewYawMax;                                        // 0x23E0(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         ViewRollMin;                                       // 0x23E4(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         ViewRollMax;                                       // 0x23E8(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_23EC[0x4];                                     // 0x23EC(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         ServerUpdateCameraTimeout;                         // 0x23F0(0x0004)(ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_23F4[0xC];                                     // 0x23F4(0x000C)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	class AEmitterCameraLensEffectBase* AddCameraLensEffect(TSubclassOf<class AEmitterCameraLensEffectBase> LensEffectEmitterClass);
	TScriptInterface<class ICameraLensEffectInterface> AddGenericCameraLensEffect(TSubclassOf<class AActor> LensEffectEmitterClass);
	class UCameraModifier* AddNewCameraModifier(TSubclassOf<class UCameraModifier> ModifierClass);
	bool BlueprintUpdateCamera(class AActor* CameraTarget, struct FVector* NewCameraLocation, struct FRotator* NewCameraRotation, float* NewCameraFOV);
	void ClearCameraLensEffects();
	class UCameraModifier* FindCameraModifierByClass(TSubclassOf<class UCameraModifier> ModifierClass);
	void OnPhotographyMultiPartCaptureEnd();
	void OnPhotographyMultiPartCaptureStart();
	void OnPhotographySessionEnd();
	void OnPhotographySessionStart();
	void PhotographyCameraModify(const struct FVector& NewCameraLocation, const struct FVector& PreviousCameraLocation, const struct FVector& OriginalCameraLocation, struct FVector* ResultCameraLocation);
	void RemoveCameraLensEffect(class AEmitterCameraLensEffectBase* Emitter);
	bool RemoveCameraModifier(class UCameraModifier* ModifierToRemove);
	void RemoveGenericCameraLensEffect(TScriptInterface<class ICameraLensEffectInterface> Emitter);
	void SetGameCameraCutThisFrame();
	void SetManualCameraFade(float InFadeAmount, const struct FLinearColor& Color, bool bInFadeAudio);
	void StartCameraFade(float FromAlpha, float ToAlpha, float Duration, const struct FLinearColor& Color, bool bShouldFadeAudio, bool bHoldWhenFinished);
	class UCameraShakeBase* StartCameraShake(TSubclassOf<class UCameraShakeBase> ShakeClass, float Scale, ECameraShakePlaySpace PlaySpace, const struct FRotator& UserPlaySpaceRot);
	class UCameraShakeBase* StartCameraShakeFromSource(TSubclassOf<class UCameraShakeBase> ShakeClass, class UCameraShakeSourceComponent* SourceComponent, float Scale, ECameraShakePlaySpace PlaySpace, const struct FRotator& UserPlaySpaceRot);
	void StopAllCameraShakes(bool bImmediately);
	void StopAllCameraShakesFromSource(class UCameraShakeSourceComponent* SourceComponent, bool bImmediately);
	void StopAllInstancesOfCameraShake(TSubclassOf<class UCameraShakeBase> Shake, bool bImmediately);
	void StopAllInstancesOfCameraShakeFromSource(TSubclassOf<class UCameraShakeBase> Shake, class UCameraShakeSourceComponent* SourceComponent, bool bImmediately);
	void StopCameraFade();
	void StopCameraShake(class UCameraShakeBase* ShakeInstance, bool bImmediately);
	void SwapPendingViewTargetWhenUsingClientSideCameraUpdates();

	struct FVector GetCameraLocation() const;
	struct FRotator GetCameraRotation() const;
	float GetFOVAngle() const;
	class APlayerController* GetOwningPlayerController() const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"PlayerCameraManager">();
	}
	static class APlayerCameraManager* GetDefaultObj()
	{
		return GetDefaultObjImpl<APlayerCameraManager>();
	}
};
static_assert(alignof(APlayerCameraManager) == 0x000010, "Wrong alignment on APlayerCameraManager");
static_assert(sizeof(APlayerCameraManager) == 0x002400, "Wrong size on APlayerCameraManager");
static_assert(offsetof(APlayerCameraManager, PCOwner) == 0x0002A0, "Member 'APlayerCameraManager::PCOwner' has a wrong offset!");
static_assert(offsetof(APlayerCameraManager, TransformComponent) == 0x0002A8, "Member 'APlayerCameraManager::TransformComponent' has a wrong offset!");
static_assert(offsetof(APlayerCameraManager, DefaultFOV) == 0x0002B8, "Member 'APlayerCameraManager::DefaultFOV' has a wrong offset!");
static_assert(offsetof(APlayerCameraManager, DefaultOrthoWidth) == 0x0002C0, "Member 'APlayerCameraManager::DefaultOrthoWidth' has a wrong offset!");
static_assert(offsetof(APlayerCameraManager, DefaultAspectRatio) == 0x0002C8, "Member 'APlayerCameraManager::DefaultAspectRatio' has a wrong offset!");
static_assert(offsetof(APlayerCameraManager, ViewTarget) == 0x000330, "Member 'APlayerCameraManager::ViewTarget' has a wrong offset!");
static_assert(offsetof(APlayerCameraManager, PendingViewTarget) == 0x000B20, "Member 'APlayerCameraManager::PendingViewTarget' has a wrong offset!");
static_assert(offsetof(APlayerCameraManager, CameraCachePrivate) == 0x001340, "Member 'APlayerCameraManager::CameraCachePrivate' has a wrong offset!");
static_assert(offsetof(APlayerCameraManager, LastFrameCameraCachePrivate) == 0x001B20, "Member 'APlayerCameraManager::LastFrameCameraCachePrivate' has a wrong offset!");
static_assert(offsetof(APlayerCameraManager, ModifierList) == 0x002300, "Member 'APlayerCameraManager::ModifierList' has a wrong offset!");
static_assert(offsetof(APlayerCameraManager, DefaultModifiers) == 0x002310, "Member 'APlayerCameraManager::DefaultModifiers' has a wrong offset!");
static_assert(offsetof(APlayerCameraManager, FreeCamDistance) == 0x002320, "Member 'APlayerCameraManager::FreeCamDistance' has a wrong offset!");
static_assert(offsetof(APlayerCameraManager, FreeCamOffset) == 0x002328, "Member 'APlayerCameraManager::FreeCamOffset' has a wrong offset!");
static_assert(offsetof(APlayerCameraManager, ViewTargetOffset) == 0x002340, "Member 'APlayerCameraManager::ViewTargetOffset' has a wrong offset!");
static_assert(offsetof(APlayerCameraManager, OnAudioFadeChangeEvent) == 0x002358, "Member 'APlayerCameraManager::OnAudioFadeChangeEvent' has a wrong offset!");
static_assert(offsetof(APlayerCameraManager, CameraLensEffects) == 0x002380, "Member 'APlayerCameraManager::CameraLensEffects' has a wrong offset!");
static_assert(offsetof(APlayerCameraManager, CachedCameraShakeMod) == 0x002390, "Member 'APlayerCameraManager::CachedCameraShakeMod' has a wrong offset!");
static_assert(offsetof(APlayerCameraManager, PostProcessBlendCache) == 0x002398, "Member 'APlayerCameraManager::PostProcessBlendCache' has a wrong offset!");
static_assert(offsetof(APlayerCameraManager, AnimCameraActor) == 0x0023C8, "Member 'APlayerCameraManager::AnimCameraActor' has a wrong offset!");
static_assert(offsetof(APlayerCameraManager, ViewPitchMin) == 0x0023D4, "Member 'APlayerCameraManager::ViewPitchMin' has a wrong offset!");
static_assert(offsetof(APlayerCameraManager, ViewPitchMax) == 0x0023D8, "Member 'APlayerCameraManager::ViewPitchMax' has a wrong offset!");
static_assert(offsetof(APlayerCameraManager, ViewYawMin) == 0x0023DC, "Member 'APlayerCameraManager::ViewYawMin' has a wrong offset!");
static_assert(offsetof(APlayerCameraManager, ViewYawMax) == 0x0023E0, "Member 'APlayerCameraManager::ViewYawMax' has a wrong offset!");
static_assert(offsetof(APlayerCameraManager, ViewRollMin) == 0x0023E4, "Member 'APlayerCameraManager::ViewRollMin' has a wrong offset!");
static_assert(offsetof(APlayerCameraManager, ViewRollMax) == 0x0023E8, "Member 'APlayerCameraManager::ViewRollMax' has a wrong offset!");
static_assert(offsetof(APlayerCameraManager, ServerUpdateCameraTimeout) == 0x0023F0, "Member 'APlayerCameraManager::ServerUpdateCameraTimeout' has a wrong offset!");

// Class Engine.ObjectElementAssetDataInterface
// 0x0008 (0x0030 - 0x0028)
class UObjectElementAssetDataInterface final : public UObject
{
public:
	uint8                                         Pad_28[0x8];                                       // 0x0028(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ObjectElementAssetDataInterface">();
	}
	static class UObjectElementAssetDataInterface* GetDefaultObj()
	{
		return GetDefaultObjImpl<UObjectElementAssetDataInterface>();
	}
};
static_assert(alignof(UObjectElementAssetDataInterface) == 0x000008, "Wrong alignment on UObjectElementAssetDataInterface");
static_assert(sizeof(UObjectElementAssetDataInterface) == 0x000030, "Wrong size on UObjectElementAssetDataInterface");

// Class Engine.PluginBlueprintLibrary
// 0x0000 (0x0028 - 0x0028)
class UPluginBlueprintLibrary final : public UBlueprintFunctionLibrary
{
public:
	static TArray<class FString> GetAdditionalPluginSearchPaths();
	static const TArray<class FString> GetAdditionalProjectPluginSearchPaths();
	static TArray<class FString> GetEnabledPluginNames();
	static bool GetPluginBaseDir(const class FString& PluginName, class FString* OutBaseDir);
	static bool GetPluginContentDir(const class FString& PluginName, class FString* OutContentDir);
	static bool GetPluginDescription(const class FString& PluginName, class FString* OutDescription);
	static bool GetPluginDescriptorFilePath(const class FString& PluginName, class FString* OutFilePath);
	static bool GetPluginEditorCustomVirtualPath(const class FString& PluginName, class FString* OutVirtualPath);
	static bool GetPluginMountedAssetPath(const class FString& PluginName, class FString* OutAssetPath);
	static bool GetPluginNameForObjectPath(const struct FSoftObjectPath& ObjectPath, class FString* OutPluginName);
	static bool GetPluginVersion(const class FString& PluginName, int32* OutVersion);
	static bool GetPluginVersionName(const class FString& PluginName, class FString* OutVersionName);
	static bool IsPluginMounted(const class FString& PluginName);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"PluginBlueprintLibrary">();
	}
	static class UPluginBlueprintLibrary* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPluginBlueprintLibrary>();
	}
};
static_assert(alignof(UPluginBlueprintLibrary) == 0x000008, "Wrong alignment on UPluginBlueprintLibrary");
static_assert(sizeof(UPluginBlueprintLibrary) == 0x000028, "Wrong size on UPluginBlueprintLibrary");

// Class Engine.PointLight
// 0x0008 (0x02B8 - 0x02B0)
class APointLight final : public ALight
{
public:
	class UPointLightComponent*                   PointLightComponent;                               // 0x02B0(0x0008)(Edit, BlueprintVisible, ExportObject, BlueprintReadOnly, ZeroConstructor, EditConst, InstancedReference, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)

public:
	void SetLightFalloffExponent(float NewLightFalloffExponent);
	void SetRadius(float NewRadius);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"PointLight">();
	}
	static class APointLight* GetDefaultObj()
	{
		return GetDefaultObjImpl<APointLight>();
	}
};
static_assert(alignof(APointLight) == 0x000008, "Wrong alignment on APointLight");
static_assert(sizeof(APointLight) == 0x0002B8, "Wrong size on APointLight");
static_assert(offsetof(APointLight, PointLightComponent) == 0x0002B0, "Member 'APointLight::PointLightComponent' has a wrong offset!");

// Class Engine.Polys
// 0x0010 (0x0038 - 0x0028)
class UPolys final : public UObject
{
public:
	uint8                                         Pad_28[0x10];                                      // 0x0028(0x0010)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"Polys">();
	}
	static class UPolys* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPolys>();
	}
};
static_assert(alignof(UPolys) == 0x000008, "Wrong alignment on UPolys");
static_assert(sizeof(UPolys) == 0x000038, "Wrong size on UPolys");

// Class Engine.SkeletalMeshActor
// 0x0080 (0x0320 - 0x02A0)
class ASkeletalMeshActor : public AActor
{
public:
	uint8                                         bShouldDoAnimNotifies : 1;                         // 0x02A0(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_2A1[0x7];                                      // 0x02A1(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	class USkeletalMeshComponent*                 SkeletalMeshComponent;                             // 0x02A8(0x0008)(Edit, BlueprintVisible, ExportObject, BlueprintReadOnly, ZeroConstructor, EditConst, InstancedReference, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	class USkeletalMesh*                          ReplicatedMesh;                                    // 0x02B0(0x0008)(Net, ZeroConstructor, Transient, RepNotify, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UPhysicsAsset*                          ReplicatedPhysAsset;                               // 0x02B8(0x0008)(Net, ZeroConstructor, Transient, RepNotify, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UMaterialInterface*                     ReplicatedMaterial0;                               // 0x02C0(0x0008)(Net, ZeroConstructor, RepNotify, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UMaterialInterface*                     ReplicatedMaterial1;                               // 0x02C8(0x0008)(Net, ZeroConstructor, RepNotify, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_2D0[0x50];                                     // 0x02D0(0x0050)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void OnRep_ReplicatedMaterial0();
	void OnRep_ReplicatedMaterial1();
	void OnRep_ReplicatedMesh();
	void OnRep_ReplicatedPhysAsset();

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"SkeletalMeshActor">();
	}
	static class ASkeletalMeshActor* GetDefaultObj()
	{
		return GetDefaultObjImpl<ASkeletalMeshActor>();
	}
};
static_assert(alignof(ASkeletalMeshActor) == 0x000008, "Wrong alignment on ASkeletalMeshActor");
static_assert(sizeof(ASkeletalMeshActor) == 0x000320, "Wrong size on ASkeletalMeshActor");
static_assert(offsetof(ASkeletalMeshActor, SkeletalMeshComponent) == 0x0002A8, "Member 'ASkeletalMeshActor::SkeletalMeshComponent' has a wrong offset!");
static_assert(offsetof(ASkeletalMeshActor, ReplicatedMesh) == 0x0002B0, "Member 'ASkeletalMeshActor::ReplicatedMesh' has a wrong offset!");
static_assert(offsetof(ASkeletalMeshActor, ReplicatedPhysAsset) == 0x0002B8, "Member 'ASkeletalMeshActor::ReplicatedPhysAsset' has a wrong offset!");
static_assert(offsetof(ASkeletalMeshActor, ReplicatedMaterial0) == 0x0002C0, "Member 'ASkeletalMeshActor::ReplicatedMaterial0' has a wrong offset!");
static_assert(offsetof(ASkeletalMeshActor, ReplicatedMaterial1) == 0x0002C8, "Member 'ASkeletalMeshActor::ReplicatedMaterial1' has a wrong offset!");

// Class Engine.PrecomputedVisibilityOverrideVolume
// 0x0030 (0x0308 - 0x02D8)
class APrecomputedVisibilityOverrideVolume final : public AVolume
{
public:
	TArray<class AActor*>                         OverrideVisibleActors;                             // 0x02D8(0x0010)(Edit, BlueprintVisible, ZeroConstructor, UObjectWrapper, NativeAccessSpecifierPublic)
	TArray<class AActor*>                         OverrideInvisibleActors;                           // 0x02E8(0x0010)(Edit, BlueprintVisible, ZeroConstructor, UObjectWrapper, NativeAccessSpecifierPublic)
	TArray<class FName>                           OverrideInvisibleLevels;                           // 0x02F8(0x0010)(Edit, BlueprintVisible, ZeroConstructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"PrecomputedVisibilityOverrideVolume">();
	}
	static class APrecomputedVisibilityOverrideVolume* GetDefaultObj()
	{
		return GetDefaultObjImpl<APrecomputedVisibilityOverrideVolume>();
	}
};
static_assert(alignof(APrecomputedVisibilityOverrideVolume) == 0x000008, "Wrong alignment on APrecomputedVisibilityOverrideVolume");
static_assert(sizeof(APrecomputedVisibilityOverrideVolume) == 0x000308, "Wrong size on APrecomputedVisibilityOverrideVolume");
static_assert(offsetof(APrecomputedVisibilityOverrideVolume, OverrideVisibleActors) == 0x0002D8, "Member 'APrecomputedVisibilityOverrideVolume::OverrideVisibleActors' has a wrong offset!");
static_assert(offsetof(APrecomputedVisibilityOverrideVolume, OverrideInvisibleActors) == 0x0002E8, "Member 'APrecomputedVisibilityOverrideVolume::OverrideInvisibleActors' has a wrong offset!");
static_assert(offsetof(APrecomputedVisibilityOverrideVolume, OverrideInvisibleLevels) == 0x0002F8, "Member 'APrecomputedVisibilityOverrideVolume::OverrideInvisibleLevels' has a wrong offset!");

// Class Engine.SMInstanceElementAssetDataInterface
// 0x0008 (0x0030 - 0x0028)
class USMInstanceElementAssetDataInterface final : public UObject
{
public:
	uint8                                         Pad_28[0x8];                                       // 0x0028(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"SMInstanceElementAssetDataInterface">();
	}
	static class USMInstanceElementAssetDataInterface* GetDefaultObj()
	{
		return GetDefaultObjImpl<USMInstanceElementAssetDataInterface>();
	}
};
static_assert(alignof(USMInstanceElementAssetDataInterface) == 0x000008, "Wrong alignment on USMInstanceElementAssetDataInterface");
static_assert(sizeof(USMInstanceElementAssetDataInterface) == 0x000030, "Wrong size on USMInstanceElementAssetDataInterface");

// Class Engine.RigidBodyBase
// 0x0000 (0x02A0 - 0x02A0)
class ARigidBodyBase : public AActor
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"RigidBodyBase">();
	}
	static class ARigidBodyBase* GetDefaultObj()
	{
		return GetDefaultObjImpl<ARigidBodyBase>();
	}
};
static_assert(alignof(ARigidBodyBase) == 0x000008, "Wrong alignment on ARigidBodyBase");
static_assert(sizeof(ARigidBodyBase) == 0x0002A0, "Wrong size on ARigidBodyBase");

// Class Engine.RadialForceActor
// 0x0008 (0x02A8 - 0x02A0)
class ARadialForceActor final : public ARigidBodyBase
{
public:
	class URadialForceComponent*                  ForceComponent;                                    // 0x02A0(0x0008)(Edit, BlueprintVisible, ExportObject, BlueprintReadOnly, ZeroConstructor, EditConst, InstancedReference, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)

public:
	void DisableForce();
	void EnableForce();
	void FireImpulse();
	void ToggleForce();

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"RadialForceActor">();
	}
	static class ARadialForceActor* GetDefaultObj()
	{
		return GetDefaultObjImpl<ARadialForceActor>();
	}
};
static_assert(alignof(ARadialForceActor) == 0x000008, "Wrong alignment on ARadialForceActor");
static_assert(sizeof(ARadialForceActor) == 0x0002A8, "Wrong size on ARadialForceActor");
static_assert(offsetof(ARadialForceActor, ForceComponent) == 0x0002A0, "Member 'ARadialForceActor::ForceComponent' has a wrong offset!");

// Class Engine.ReplicationDriver
// 0x0000 (0x0028 - 0x0028)
class UReplicationDriver final : public UObject
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ReplicationDriver">();
	}
	static class UReplicationDriver* GetDefaultObj()
	{
		return GetDefaultObjImpl<UReplicationDriver>();
	}
};
static_assert(alignof(UReplicationDriver) == 0x000008, "Wrong alignment on UReplicationDriver");
static_assert(sizeof(UReplicationDriver) == 0x000028, "Wrong size on UReplicationDriver");

// Class Engine.AsyncActionLoadPrimaryAsset
// 0x0010 (0x0088 - 0x0078)
class UAsyncActionLoadPrimaryAsset final : public UAsyncActionLoadPrimaryAssetBase
{
public:
	TMulticastInlineDelegate<void(class UObject* Loaded)> Completed;                                 // 0x0078(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)

public:
	static class UAsyncActionLoadPrimaryAsset* AsyncLoadPrimaryAsset(class UObject* WorldContextObject, const struct FPrimaryAssetId& PrimaryAsset, const TArray<class FName>& LoadBundles);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AsyncActionLoadPrimaryAsset">();
	}
	static class UAsyncActionLoadPrimaryAsset* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAsyncActionLoadPrimaryAsset>();
	}
};
static_assert(alignof(UAsyncActionLoadPrimaryAsset) == 0x000008, "Wrong alignment on UAsyncActionLoadPrimaryAsset");
static_assert(sizeof(UAsyncActionLoadPrimaryAsset) == 0x000088, "Wrong size on UAsyncActionLoadPrimaryAsset");
static_assert(offsetof(UAsyncActionLoadPrimaryAsset, Completed) == 0x000078, "Member 'UAsyncActionLoadPrimaryAsset::Completed' has a wrong offset!");

// Class Engine.ReplicationConnectionDriver
// 0x0000 (0x0028 - 0x0028)
class UReplicationConnectionDriver final : public UObject
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ReplicationConnectionDriver">();
	}
	static class UReplicationConnectionDriver* GetDefaultObj()
	{
		return GetDefaultObjImpl<UReplicationConnectionDriver>();
	}
};
static_assert(alignof(UReplicationConnectionDriver) == 0x000008, "Wrong alignment on UReplicationConnectionDriver");
static_assert(sizeof(UReplicationConnectionDriver) == 0x000028, "Wrong size on UReplicationConnectionDriver");

// Class Engine.SMInstanceElementSelectionInterface
// 0x0008 (0x0030 - 0x0028)
class USMInstanceElementSelectionInterface final : public UObject
{
public:
	uint8                                         Pad_28[0x8];                                       // 0x0028(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"SMInstanceElementSelectionInterface">();
	}
	static class USMInstanceElementSelectionInterface* GetDefaultObj()
	{
		return GetDefaultObjImpl<USMInstanceElementSelectionInterface>();
	}
};
static_assert(alignof(USMInstanceElementSelectionInterface) == 0x000008, "Wrong alignment on USMInstanceElementSelectionInterface");
static_assert(sizeof(USMInstanceElementSelectionInterface) == 0x000030, "Wrong size on USMInstanceElementSelectionInterface");

// Class Engine.WorldPartitionRuntimeHash
// 0x0050 (0x0078 - 0x0028)
class UWorldPartitionRuntimeHash : public UObject
{
public:
	uint8                                         Pad_28[0x50];                                      // 0x0028(0x0050)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"WorldPartitionRuntimeHash">();
	}
	static class UWorldPartitionRuntimeHash* GetDefaultObj()
	{
		return GetDefaultObjImpl<UWorldPartitionRuntimeHash>();
	}
};
static_assert(alignof(UWorldPartitionRuntimeHash) == 0x000008, "Wrong alignment on UWorldPartitionRuntimeHash");
static_assert(sizeof(UWorldPartitionRuntimeHash) == 0x000078, "Wrong size on UWorldPartitionRuntimeHash");

// Class Engine.WorldPartitionRuntimeHashSet
// 0x0068 (0x00E0 - 0x0078)
class UWorldPartitionRuntimeHashSet final : public UWorldPartitionRuntimeHash
{
public:
	TArray<class UWorldPartitionRuntimeCell*>     NonSpatiallyLoadedRuntimeCells;                    // 0x0078(0x0010)(ZeroConstructor, UObjectWrapper, NativeAccessSpecifierPublic)
	uint8                                         Pad_88[0x58];                                      // 0x0088(0x0058)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"WorldPartitionRuntimeHashSet">();
	}
	static class UWorldPartitionRuntimeHashSet* GetDefaultObj()
	{
		return GetDefaultObjImpl<UWorldPartitionRuntimeHashSet>();
	}
};
static_assert(alignof(UWorldPartitionRuntimeHashSet) == 0x000008, "Wrong alignment on UWorldPartitionRuntimeHashSet");
static_assert(sizeof(UWorldPartitionRuntimeHashSet) == 0x0000E0, "Wrong size on UWorldPartitionRuntimeHashSet");
static_assert(offsetof(UWorldPartitionRuntimeHashSet, NonSpatiallyLoadedRuntimeCells) == 0x000078, "Member 'UWorldPartitionRuntimeHashSet::NonSpatiallyLoadedRuntimeCells' has a wrong offset!");

// Class Engine.RuntimePartition
// 0x0000 (0x0028 - 0x0028)
class URuntimePartition : public UObject
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"RuntimePartition">();
	}
	static class URuntimePartition* GetDefaultObj()
	{
		return GetDefaultObjImpl<URuntimePartition>();
	}
};
static_assert(alignof(URuntimePartition) == 0x000008, "Wrong alignment on URuntimePartition");
static_assert(sizeof(URuntimePartition) == 0x000028, "Wrong size on URuntimePartition");

// Class Engine.AsyncActionChangePrimaryAssetBundles
// 0x0010 (0x0088 - 0x0078)
class UAsyncActionChangePrimaryAssetBundles final : public UAsyncActionLoadPrimaryAssetBase
{
public:
	TMulticastInlineDelegate<void()>              Completed;                                         // 0x0078(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)

public:
	static class UAsyncActionChangePrimaryAssetBundles* AsyncChangeBundleStateForMatchingPrimaryAssets(class UObject* WorldContextObject, const TArray<class FName>& NewBundles, const TArray<class FName>& OldBundles);
	static class UAsyncActionChangePrimaryAssetBundles* AsyncChangeBundleStateForPrimaryAssetList(class UObject* WorldContextObject, const TArray<struct FPrimaryAssetId>& PrimaryAssetList, const TArray<class FName>& AddBundles, const TArray<class FName>& RemoveBundles);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AsyncActionChangePrimaryAssetBundles">();
	}
	static class UAsyncActionChangePrimaryAssetBundles* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAsyncActionChangePrimaryAssetBundles>();
	}
};
static_assert(alignof(UAsyncActionChangePrimaryAssetBundles) == 0x000008, "Wrong alignment on UAsyncActionChangePrimaryAssetBundles");
static_assert(sizeof(UAsyncActionChangePrimaryAssetBundles) == 0x000088, "Wrong size on UAsyncActionChangePrimaryAssetBundles");
static_assert(offsetof(UAsyncActionChangePrimaryAssetBundles, Completed) == 0x000078, "Member 'UAsyncActionChangePrimaryAssetBundles::Completed' has a wrong offset!");

// Class Engine.RuntimePartitionLevelStreaming
// 0x0000 (0x0028 - 0x0028)
class URuntimePartitionLevelStreaming final : public URuntimePartition
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"RuntimePartitionLevelStreaming">();
	}
	static class URuntimePartitionLevelStreaming* GetDefaultObj()
	{
		return GetDefaultObjImpl<URuntimePartitionLevelStreaming>();
	}
};
static_assert(alignof(URuntimePartitionLevelStreaming) == 0x000008, "Wrong alignment on URuntimePartitionLevelStreaming");
static_assert(sizeof(URuntimePartitionLevelStreaming) == 0x000028, "Wrong size on URuntimePartitionLevelStreaming");

// Class Engine.AutoDestroySubsystem
// 0x0010 (0x0050 - 0x0040)
class UAutoDestroySubsystem final : public UTickableWorldSubsystem
{
public:
	TArray<class AActor*>                         ActorsToPoll;                                      // 0x0040(0x0010)(ZeroConstructor, UObjectWrapper, NativeAccessSpecifierPrivate)

public:
	void OnActorEndPlay(class AActor* Actor, EEndPlayReason EndPlayReason);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AutoDestroySubsystem">();
	}
	static class UAutoDestroySubsystem* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAutoDestroySubsystem>();
	}
};
static_assert(alignof(UAutoDestroySubsystem) == 0x000008, "Wrong alignment on UAutoDestroySubsystem");
static_assert(sizeof(UAutoDestroySubsystem) == 0x000050, "Wrong size on UAutoDestroySubsystem");
static_assert(offsetof(UAutoDestroySubsystem, ActorsToPoll) == 0x000040, "Member 'UAutoDestroySubsystem::ActorsToPoll' has a wrong offset!");

// Class Engine.RuntimePartitionPersistent
// 0x0000 (0x0028 - 0x0028)
class URuntimePartitionPersistent final : public URuntimePartition
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"RuntimePartitionPersistent">();
	}
	static class URuntimePartitionPersistent* GetDefaultObj()
	{
		return GetDefaultObjImpl<URuntimePartitionPersistent>();
	}
};
static_assert(alignof(URuntimePartitionPersistent) == 0x000008, "Wrong alignment on URuntimePartitionPersistent");
static_assert(sizeof(URuntimePartitionPersistent) == 0x000028, "Wrong size on URuntimePartitionPersistent");

// Class Engine.RVOAvoidanceInterface
// 0x0000 (0x0000 - 0x0000)
class IRVOAvoidanceInterface final
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"RVOAvoidanceInterface">();
	}
	static class IRVOAvoidanceInterface* GetDefaultObj()
	{
		return GetDefaultObjImpl<IRVOAvoidanceInterface>();
	}

	class UObject* AsUObject()
	{
		return reinterpret_cast<UObject*>(this);
	}
	const class UObject* AsUObject() const
	{
		return reinterpret_cast<const UObject*>(this);
	}
};
static_assert(alignof(IRVOAvoidanceInterface) == 0x000001, "Wrong alignment on IRVOAvoidanceInterface");
static_assert(sizeof(IRVOAvoidanceInterface) == 0x000001, "Wrong size on IRVOAvoidanceInterface");

// Class Engine.Scene
// 0x0000 (0x0028 - 0x0028)
class UScene final : public UObject
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"Scene">();
	}
	static class UScene* GetDefaultObj()
	{
		return GetDefaultObjImpl<UScene>();
	}
};
static_assert(alignof(UScene) == 0x000008, "Wrong alignment on UScene");
static_assert(sizeof(UScene) == 0x000028, "Wrong size on UScene");

// Class Engine.AnimClassInterface
// 0x0000 (0x0000 - 0x0000)
class IAnimClassInterface final
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AnimClassInterface">();
	}
	static class IAnimClassInterface* GetDefaultObj()
	{
		return GetDefaultObjImpl<IAnimClassInterface>();
	}

	class UObject* AsUObject()
	{
		return reinterpret_cast<UObject*>(this);
	}
	const class UObject* AsUObject() const
	{
		return reinterpret_cast<const UObject*>(this);
	}
};
static_assert(alignof(IAnimClassInterface) == 0x000001, "Wrong alignment on IAnimClassInterface");
static_assert(sizeof(IAnimClassInterface) == 0x000001, "Wrong size on IAnimClassInterface");

// Class Engine.SceneCapture2D
// 0x0008 (0x02B8 - 0x02B0)
class ASceneCapture2D : public ASceneCapture
{
public:
	class USceneCaptureComponent2D*               CaptureComponent2D;                                // 0x02B0(0x0008)(Edit, BlueprintVisible, ExportObject, BlueprintReadOnly, ZeroConstructor, EditConst, InstancedReference, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)

public:
	void OnInterpToggle(bool bEnable);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"SceneCapture2D">();
	}
	static class ASceneCapture2D* GetDefaultObj()
	{
		return GetDefaultObjImpl<ASceneCapture2D>();
	}
};
static_assert(alignof(ASceneCapture2D) == 0x000008, "Wrong alignment on ASceneCapture2D");
static_assert(sizeof(ASceneCapture2D) == 0x0002B8, "Wrong size on ASceneCapture2D");
static_assert(offsetof(ASceneCapture2D, CaptureComponent2D) == 0x0002B0, "Member 'ASceneCapture2D::CaptureComponent2D' has a wrong offset!");

// Class Engine.SceneCaptureComponent2D
// 0x07F0 (0x0B50 - 0x0360)
class USceneCaptureComponent2D : public USceneCaptureComponent
{
public:
	ECameraProjectionMode                         ProjectionType;                                    // 0x0358(0x0001)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_359[0x3];                                      // 0x0359(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         FOVAngle;                                          // 0x035C(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         OrthoWidth;                                        // 0x0360(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_364[0x4];                                      // 0x0364(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	class UTextureRenderTarget2D*                 TextureTarget;                                     // 0x0368(0x0008)(Edit, BlueprintVisible, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	ESceneCaptureCompositeMode                    CompositeMode;                                     // 0x0370(0x0001)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_371[0xF];                                      // 0x0371(0x000F)(Fixing Size After Last Property [ Dumper-7 ])
	struct FPostProcessSettings                   PostProcessSettings;                               // 0x0380(0x06E0)(Edit, BlueprintVisible, Interp, NativeAccessSpecifierPublic)
	float                                         PostProcessBlendWeight;                            // 0x0A60(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bOverride_CustomNearClippingPlane : 1;             // 0x0A64(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_A65[0x3];                                      // 0x0A65(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         CustomNearClippingPlane;                           // 0x0A68(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bUseCustomProjectionMatrix;                        // 0x0A6C(0x0001)(BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_A6D[0x3];                                      // 0x0A6D(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	struct FMatrix                                CustomProjectionMatrix;                            // 0x0A70(0x0080)(BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, NativeAccessSpecifierPublic)
	bool                                          bUseFauxOrthoViewPos;                              // 0x0AF0(0x0001)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bEnableOrthographicTiling;                         // 0x0AF1(0x0001)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_AF2[0x2];                                      // 0x0AF2(0x0002)(Fixing Size After Last Property [ Dumper-7 ])
	int32                                         NumXTiles;                                         // 0x0AF4(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         NumYTiles;                                         // 0x0AF8(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bIsDisableMFSR;                                    // 0x0AFC(0x0001)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bEnableClipPlane;                                  // 0x0AFD(0x0001)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_AFE[0x2];                                      // 0x0AFE(0x0002)(Fixing Size After Last Property [ Dumper-7 ])
	struct FVector                                ClipPlaneBase;                                     // 0x0B00(0x0018)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector                                ClipPlaneNormal;                                   // 0x0B18(0x0018)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bCameraCutThisFrame : 1;                           // 0x0B30(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (BlueprintVisible, Transient, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bConsiderUnrenderedOpaquePixelAsFullyTranslucent : 1; // 0x0B30(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_B31[0x1F];                                     // 0x0B31(0x001F)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void AddOrUpdateBlendable(TScriptInterface<class IBlendableInterface> InBlendableObject, float InWeight);
	void CaptureScene();
	void RemoveBlendable(TScriptInterface<class IBlendableInterface> InBlendableObject);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"SceneCaptureComponent2D">();
	}
	static class USceneCaptureComponent2D* GetDefaultObj()
	{
		return GetDefaultObjImpl<USceneCaptureComponent2D>();
	}
};
static_assert(alignof(USceneCaptureComponent2D) == 0x000010, "Wrong alignment on USceneCaptureComponent2D");
static_assert(sizeof(USceneCaptureComponent2D) == 0x000B50, "Wrong size on USceneCaptureComponent2D");
static_assert(offsetof(USceneCaptureComponent2D, ProjectionType) == 0x000358, "Member 'USceneCaptureComponent2D::ProjectionType' has a wrong offset!");
static_assert(offsetof(USceneCaptureComponent2D, FOVAngle) == 0x00035C, "Member 'USceneCaptureComponent2D::FOVAngle' has a wrong offset!");
static_assert(offsetof(USceneCaptureComponent2D, OrthoWidth) == 0x000360, "Member 'USceneCaptureComponent2D::OrthoWidth' has a wrong offset!");
static_assert(offsetof(USceneCaptureComponent2D, TextureTarget) == 0x000368, "Member 'USceneCaptureComponent2D::TextureTarget' has a wrong offset!");
static_assert(offsetof(USceneCaptureComponent2D, CompositeMode) == 0x000370, "Member 'USceneCaptureComponent2D::CompositeMode' has a wrong offset!");
static_assert(offsetof(USceneCaptureComponent2D, PostProcessSettings) == 0x000380, "Member 'USceneCaptureComponent2D::PostProcessSettings' has a wrong offset!");
static_assert(offsetof(USceneCaptureComponent2D, PostProcessBlendWeight) == 0x000A60, "Member 'USceneCaptureComponent2D::PostProcessBlendWeight' has a wrong offset!");
static_assert(offsetof(USceneCaptureComponent2D, CustomNearClippingPlane) == 0x000A68, "Member 'USceneCaptureComponent2D::CustomNearClippingPlane' has a wrong offset!");
static_assert(offsetof(USceneCaptureComponent2D, bUseCustomProjectionMatrix) == 0x000A6C, "Member 'USceneCaptureComponent2D::bUseCustomProjectionMatrix' has a wrong offset!");
static_assert(offsetof(USceneCaptureComponent2D, CustomProjectionMatrix) == 0x000A70, "Member 'USceneCaptureComponent2D::CustomProjectionMatrix' has a wrong offset!");
static_assert(offsetof(USceneCaptureComponent2D, bUseFauxOrthoViewPos) == 0x000AF0, "Member 'USceneCaptureComponent2D::bUseFauxOrthoViewPos' has a wrong offset!");
static_assert(offsetof(USceneCaptureComponent2D, bEnableOrthographicTiling) == 0x000AF1, "Member 'USceneCaptureComponent2D::bEnableOrthographicTiling' has a wrong offset!");
static_assert(offsetof(USceneCaptureComponent2D, NumXTiles) == 0x000AF4, "Member 'USceneCaptureComponent2D::NumXTiles' has a wrong offset!");
static_assert(offsetof(USceneCaptureComponent2D, NumYTiles) == 0x000AF8, "Member 'USceneCaptureComponent2D::NumYTiles' has a wrong offset!");
static_assert(offsetof(USceneCaptureComponent2D, bIsDisableMFSR) == 0x000AFC, "Member 'USceneCaptureComponent2D::bIsDisableMFSR' has a wrong offset!");
static_assert(offsetof(USceneCaptureComponent2D, bEnableClipPlane) == 0x000AFD, "Member 'USceneCaptureComponent2D::bEnableClipPlane' has a wrong offset!");
static_assert(offsetof(USceneCaptureComponent2D, ClipPlaneBase) == 0x000B00, "Member 'USceneCaptureComponent2D::ClipPlaneBase' has a wrong offset!");
static_assert(offsetof(USceneCaptureComponent2D, ClipPlaneNormal) == 0x000B18, "Member 'USceneCaptureComponent2D::ClipPlaneNormal' has a wrong offset!");

// Class Engine.SceneCaptureComponentCube
// 0x0010 (0x0370 - 0x0360)
class USceneCaptureComponentCube final : public USceneCaptureComponent
{
public:
	class UTextureRenderTargetCube*               TextureTarget;                                     // 0x0358(0x0008)(Edit, BlueprintVisible, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bCaptureRotation;                                  // 0x0360(0x0001)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_361[0xF];                                      // 0x0361(0x000F)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void CaptureScene();

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"SceneCaptureComponentCube">();
	}
	static class USceneCaptureComponentCube* GetDefaultObj()
	{
		return GetDefaultObjImpl<USceneCaptureComponentCube>();
	}
};
static_assert(alignof(USceneCaptureComponentCube) == 0x000010, "Wrong alignment on USceneCaptureComponentCube");
static_assert(sizeof(USceneCaptureComponentCube) == 0x000370, "Wrong size on USceneCaptureComponentCube");
static_assert(offsetof(USceneCaptureComponentCube, TextureTarget) == 0x000358, "Member 'USceneCaptureComponentCube::TextureTarget' has a wrong offset!");
static_assert(offsetof(USceneCaptureComponentCube, bCaptureRotation) == 0x000360, "Member 'USceneCaptureComponentCube::bCaptureRotation' has a wrong offset!");

// Class Engine.SceneCaptureCube
// 0x0008 (0x02B8 - 0x02B0)
class ASceneCaptureCube final : public ASceneCapture
{
public:
	class USceneCaptureComponentCube*             CaptureComponentCube;                              // 0x02B0(0x0008)(Edit, BlueprintVisible, ExportObject, BlueprintReadOnly, ZeroConstructor, EditConst, InstancedReference, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)

public:
	void OnInterpToggle(bool bEnable);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"SceneCaptureCube">();
	}
	static class ASceneCaptureCube* GetDefaultObj()
	{
		return GetDefaultObjImpl<ASceneCaptureCube>();
	}
};
static_assert(alignof(ASceneCaptureCube) == 0x000008, "Wrong alignment on ASceneCaptureCube");
static_assert(sizeof(ASceneCaptureCube) == 0x0002B8, "Wrong size on ASceneCaptureCube");
static_assert(offsetof(ASceneCaptureCube, CaptureComponentCube) == 0x0002B0, "Member 'ASceneCaptureCube::CaptureComponentCube' has a wrong offset!");

// Class Engine.ShadowMapTexture2D
// 0x0000 (0x0280 - 0x0280)
class UShadowMapTexture2D final : public UTexture2D
{
public:
	EShadowMapFlags                               ShadowmapFlags;                                    // 0x0278(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_279[0x7];                                      // 0x0279(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ShadowMapTexture2D">();
	}
	static class UShadowMapTexture2D* GetDefaultObj()
	{
		return GetDefaultObjImpl<UShadowMapTexture2D>();
	}
};
static_assert(alignof(UShadowMapTexture2D) == 0x000010, "Wrong alignment on UShadowMapTexture2D");
static_assert(sizeof(UShadowMapTexture2D) == 0x000280, "Wrong size on UShadowMapTexture2D");
static_assert(offsetof(UShadowMapTexture2D, ShadowmapFlags) == 0x000278, "Member 'UShadowMapTexture2D::ShadowmapFlags' has a wrong offset!");

// Class Engine.SkeletalMeshSocket
// 0x0060 (0x0088 - 0x0028)
class USkeletalMeshSocket final : public UObject
{
public:
	class FName                                   SocketName;                                        // 0x0028(0x0008)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, EditConst, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FName                                   BoneName;                                          // 0x0030(0x0008)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, EditConst, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector                                RelativeLocation;                                  // 0x0038(0x0018)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FRotator                               RelativeRotation;                                  // 0x0050(0x0018)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
	struct FVector                                RelativeScale;                                     // 0x0068(0x0018)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bForceAlwaysAnimated;                              // 0x0080(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_81[0x7];                                       // 0x0081(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void InitializeSocketFromLocation(const class USkeletalMeshComponent* SkelComp, const struct FVector& WorldLocation, const struct FVector& WorldNormal);

	struct FVector GetSocketLocation(const class USkeletalMeshComponent* SkelComp) const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"SkeletalMeshSocket">();
	}
	static class USkeletalMeshSocket* GetDefaultObj()
	{
		return GetDefaultObjImpl<USkeletalMeshSocket>();
	}
};
static_assert(alignof(USkeletalMeshSocket) == 0x000008, "Wrong alignment on USkeletalMeshSocket");
static_assert(sizeof(USkeletalMeshSocket) == 0x000088, "Wrong size on USkeletalMeshSocket");
static_assert(offsetof(USkeletalMeshSocket, SocketName) == 0x000028, "Member 'USkeletalMeshSocket::SocketName' has a wrong offset!");
static_assert(offsetof(USkeletalMeshSocket, BoneName) == 0x000030, "Member 'USkeletalMeshSocket::BoneName' has a wrong offset!");
static_assert(offsetof(USkeletalMeshSocket, RelativeLocation) == 0x000038, "Member 'USkeletalMeshSocket::RelativeLocation' has a wrong offset!");
static_assert(offsetof(USkeletalMeshSocket, RelativeRotation) == 0x000050, "Member 'USkeletalMeshSocket::RelativeRotation' has a wrong offset!");
static_assert(offsetof(USkeletalMeshSocket, RelativeScale) == 0x000068, "Member 'USkeletalMeshSocket::RelativeScale' has a wrong offset!");
static_assert(offsetof(USkeletalMeshSocket, bForceAlwaysAnimated) == 0x000080, "Member 'USkeletalMeshSocket::bForceAlwaysAnimated' has a wrong offset!");

// Class Engine.SkyLightComponent
// 0x01F0 (0x04D0 - 0x02E0)
class USkyLightComponent final : public ULightComponentBase
{
public:
	bool                                          bRealTimeCapture;                                  // 0x02D8(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	ESkyLightSourceType                           SourceType;                                        // 0x02D9(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_2DA[0x6];                                      // 0x02DA(0x0006)(Fixing Size After Last Property [ Dumper-7 ])
	class UTextureCube*                           Cubemap;                                           // 0x02E0(0x0008)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         SourceCubemapAngle;                                // 0x02E8(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         CubemapResolution;                                 // 0x02EC(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         SkyDistanceThreshold;                              // 0x02F0(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bCaptureEmissiveOnly;                              // 0x02F4(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bLowerHemisphereIsBlack;                           // 0x02F5(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_2F6[0x2];                                      // 0x02F6(0x0002)(Fixing Size After Last Property [ Dumper-7 ])
	struct FLinearColor                           LowerHemisphereColor;                              // 0x02F8(0x0010)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         OcclusionMaxDistance;                              // 0x0308(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         Contrast;                                          // 0x030C(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         OcclusionExponent;                                 // 0x0310(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         MinOcclusion;                                      // 0x0314(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FColor                                 OcclusionTint;                                     // 0x0318(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bCloudAmbientOcclusion : 1;                        // 0x031C(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_31D[0x3];                                      // 0x031D(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         CloudAmbientOcclusionStrength;                     // 0x0320(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         CloudAmbientOcclusionExtent;                       // 0x0324(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         CloudAmbientOcclusionMapResolutionScale;           // 0x0328(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         CloudAmbientOcclusionApertureScale;                // 0x032C(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EOcclusionCombineMode                         OcclusionCombineMode;                              // 0x0330(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_331[0x3];                                      // 0x0331(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	uint8                                         bShowIlluminanceMeter : 1;                         // 0x0334(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_335[0xB3];                                     // 0x0335(0x00B3)(Fixing Size After Last Property [ Dumper-7 ])
	class UTextureCube*                           BlendDestinationCubemap;                           // 0x03E8(0x0008)(ZeroConstructor, Transient, NoDestructor, Protected, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_3F0[0xE0];                                     // 0x03F0(0x00E0)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void RecaptureSky();
	void SetCubemap(class UTextureCube* NewCubemap);
	void SetCubemapBlend(class UTextureCube* SourceCubemap, class UTextureCube* DestinationCubemap, float InBlendFraction);
	void SetIndirectLightingIntensity(float NewIntensity);
	void SetIntensity(float NewIntensity);
	void SetLightColor(const struct FLinearColor& NewLightColor);
	void SetLowerHemisphereColor(const struct FLinearColor& InLowerHemisphereColor);
	void SetMinOcclusion(float InMinOcclusion);
	void SetOcclusionContrast(float InOcclusionContrast);
	void SetOcclusionExponent(float InOcclusionExponent);
	void SetOcclusionTint(const struct FColor& InTint);
	void SetSourceCubemapAngle(float NewValue);
	void SetVolumetricScatteringIntensity(float NewIntensity);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"SkyLightComponent">();
	}
	static class USkyLightComponent* GetDefaultObj()
	{
		return GetDefaultObjImpl<USkyLightComponent>();
	}
};
static_assert(alignof(USkyLightComponent) == 0x000010, "Wrong alignment on USkyLightComponent");
static_assert(sizeof(USkyLightComponent) == 0x0004D0, "Wrong size on USkyLightComponent");
static_assert(offsetof(USkyLightComponent, bRealTimeCapture) == 0x0002D8, "Member 'USkyLightComponent::bRealTimeCapture' has a wrong offset!");
static_assert(offsetof(USkyLightComponent, SourceType) == 0x0002D9, "Member 'USkyLightComponent::SourceType' has a wrong offset!");
static_assert(offsetof(USkyLightComponent, Cubemap) == 0x0002E0, "Member 'USkyLightComponent::Cubemap' has a wrong offset!");
static_assert(offsetof(USkyLightComponent, SourceCubemapAngle) == 0x0002E8, "Member 'USkyLightComponent::SourceCubemapAngle' has a wrong offset!");
static_assert(offsetof(USkyLightComponent, CubemapResolution) == 0x0002EC, "Member 'USkyLightComponent::CubemapResolution' has a wrong offset!");
static_assert(offsetof(USkyLightComponent, SkyDistanceThreshold) == 0x0002F0, "Member 'USkyLightComponent::SkyDistanceThreshold' has a wrong offset!");
static_assert(offsetof(USkyLightComponent, bCaptureEmissiveOnly) == 0x0002F4, "Member 'USkyLightComponent::bCaptureEmissiveOnly' has a wrong offset!");
static_assert(offsetof(USkyLightComponent, bLowerHemisphereIsBlack) == 0x0002F5, "Member 'USkyLightComponent::bLowerHemisphereIsBlack' has a wrong offset!");
static_assert(offsetof(USkyLightComponent, LowerHemisphereColor) == 0x0002F8, "Member 'USkyLightComponent::LowerHemisphereColor' has a wrong offset!");
static_assert(offsetof(USkyLightComponent, OcclusionMaxDistance) == 0x000308, "Member 'USkyLightComponent::OcclusionMaxDistance' has a wrong offset!");
static_assert(offsetof(USkyLightComponent, Contrast) == 0x00030C, "Member 'USkyLightComponent::Contrast' has a wrong offset!");
static_assert(offsetof(USkyLightComponent, OcclusionExponent) == 0x000310, "Member 'USkyLightComponent::OcclusionExponent' has a wrong offset!");
static_assert(offsetof(USkyLightComponent, MinOcclusion) == 0x000314, "Member 'USkyLightComponent::MinOcclusion' has a wrong offset!");
static_assert(offsetof(USkyLightComponent, OcclusionTint) == 0x000318, "Member 'USkyLightComponent::OcclusionTint' has a wrong offset!");
static_assert(offsetof(USkyLightComponent, CloudAmbientOcclusionStrength) == 0x000320, "Member 'USkyLightComponent::CloudAmbientOcclusionStrength' has a wrong offset!");
static_assert(offsetof(USkyLightComponent, CloudAmbientOcclusionExtent) == 0x000324, "Member 'USkyLightComponent::CloudAmbientOcclusionExtent' has a wrong offset!");
static_assert(offsetof(USkyLightComponent, CloudAmbientOcclusionMapResolutionScale) == 0x000328, "Member 'USkyLightComponent::CloudAmbientOcclusionMapResolutionScale' has a wrong offset!");
static_assert(offsetof(USkyLightComponent, CloudAmbientOcclusionApertureScale) == 0x00032C, "Member 'USkyLightComponent::CloudAmbientOcclusionApertureScale' has a wrong offset!");
static_assert(offsetof(USkyLightComponent, OcclusionCombineMode) == 0x000330, "Member 'USkyLightComponent::OcclusionCombineMode' has a wrong offset!");
static_assert(offsetof(USkyLightComponent, BlendDestinationCubemap) == 0x0003E8, "Member 'USkyLightComponent::BlendDestinationCubemap' has a wrong offset!");

// Class Engine.AnimCompress_RemoveEverySecondKey
// 0x0008 (0x0048 - 0x0040)
class UAnimCompress_RemoveEverySecondKey final : public UAnimCompress
{
public:
	int32                                         MinKeys;                                           // 0x0040(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bStartAtSecondKey : 1;                             // 0x0044(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_45[0x3];                                       // 0x0045(0x0003)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AnimCompress_RemoveEverySecondKey">();
	}
	static class UAnimCompress_RemoveEverySecondKey* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAnimCompress_RemoveEverySecondKey>();
	}
};
static_assert(alignof(UAnimCompress_RemoveEverySecondKey) == 0x000008, "Wrong alignment on UAnimCompress_RemoveEverySecondKey");
static_assert(sizeof(UAnimCompress_RemoveEverySecondKey) == 0x000048, "Wrong size on UAnimCompress_RemoveEverySecondKey");
static_assert(offsetof(UAnimCompress_RemoveEverySecondKey, MinKeys) == 0x000040, "Member 'UAnimCompress_RemoveEverySecondKey::MinKeys' has a wrong offset!");

// Class Engine.SMInstanceManager
// 0x0000 (0x0000 - 0x0000)
class ISMInstanceManager final
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"SMInstanceManager">();
	}
	static class ISMInstanceManager* GetDefaultObj()
	{
		return GetDefaultObjImpl<ISMInstanceManager>();
	}

	class UObject* AsUObject()
	{
		return reinterpret_cast<UObject*>(this);
	}
	const class UObject* AsUObject() const
	{
		return reinterpret_cast<const UObject*>(this);
	}
};
static_assert(alignof(ISMInstanceManager) == 0x000001, "Wrong alignment on ISMInstanceManager");
static_assert(sizeof(ISMInstanceManager) == 0x000001, "Wrong size on ISMInstanceManager");

// Class Engine.SMInstanceManagerProvider
// 0x0000 (0x0000 - 0x0000)
class ISMInstanceManagerProvider final
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"SMInstanceManagerProvider">();
	}
	static class ISMInstanceManagerProvider* GetDefaultObj()
	{
		return GetDefaultObjImpl<ISMInstanceManagerProvider>();
	}

	class UObject* AsUObject()
	{
		return reinterpret_cast<UObject*>(this);
	}
	const class UObject* AsUObject() const
	{
		return reinterpret_cast<const UObject*>(this);
	}
};
static_assert(alignof(ISMInstanceManagerProvider) == 0x000001, "Wrong alignment on ISMInstanceManagerProvider");
static_assert(sizeof(ISMInstanceManagerProvider) == 0x000001, "Wrong size on ISMInstanceManagerProvider");

// Class Engine.WorldPartitionEditorHash
// 0x0000 (0x0028 - 0x0028)
class UWorldPartitionEditorHash : public UObject
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"WorldPartitionEditorHash">();
	}
	static class UWorldPartitionEditorHash* GetDefaultObj()
	{
		return GetDefaultObjImpl<UWorldPartitionEditorHash>();
	}
};
static_assert(alignof(UWorldPartitionEditorHash) == 0x000008, "Wrong alignment on UWorldPartitionEditorHash");
static_assert(sizeof(UWorldPartitionEditorHash) == 0x000028, "Wrong size on UWorldPartitionEditorHash");

// Class Engine.WorldPartitionEditorSpatialHash
// 0x0000 (0x0028 - 0x0028)
class UWorldPartitionEditorSpatialHash final : public UWorldPartitionEditorHash
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"WorldPartitionEditorSpatialHash">();
	}
	static class UWorldPartitionEditorSpatialHash* GetDefaultObj()
	{
		return GetDefaultObjImpl<UWorldPartitionEditorSpatialHash>();
	}
};
static_assert(alignof(UWorldPartitionEditorSpatialHash) == 0x000008, "Wrong alignment on UWorldPartitionEditorSpatialHash");
static_assert(sizeof(UWorldPartitionEditorSpatialHash) == 0x000028, "Wrong size on UWorldPartitionEditorSpatialHash");

// Class Engine.SoundAttenuation
// 0x03D0 (0x03F8 - 0x0028)
class USoundAttenuation final : public UObject
{
public:
	struct FSoundAttenuationSettings              Attenuation;                                       // 0x0028(0x03D0)(Edit, BlueprintVisible, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"SoundAttenuation">();
	}
	static class USoundAttenuation* GetDefaultObj()
	{
		return GetDefaultObjImpl<USoundAttenuation>();
	}
};
static_assert(alignof(USoundAttenuation) == 0x000008, "Wrong alignment on USoundAttenuation");
static_assert(sizeof(USoundAttenuation) == 0x0003F8, "Wrong size on USoundAttenuation");
static_assert(offsetof(USoundAttenuation, Attenuation) == 0x000028, "Member 'USoundAttenuation::Attenuation' has a wrong offset!");

// Class Engine.SoundEffectPresetWidgetInterface
// 0x0000 (0x0000 - 0x0000)
class ISoundEffectPresetWidgetInterface final
{
public:
	TSubclassOf<class USoundEffectPreset> GetClass();
	void OnConstructed(class USoundEffectPreset* Preset);
	void OnPropertyChanged(class USoundEffectPreset* Preset, class FName PropertyName);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"SoundEffectPresetWidgetInterface">();
	}
	static class ISoundEffectPresetWidgetInterface* GetDefaultObj()
	{
		return GetDefaultObjImpl<ISoundEffectPresetWidgetInterface>();
	}

	class UObject* AsUObject()
	{
		return reinterpret_cast<UObject*>(this);
	}
	const class UObject* AsUObject() const
	{
		return reinterpret_cast<const UObject*>(this);
	}
};
static_assert(alignof(ISoundEffectPresetWidgetInterface) == 0x000001, "Wrong alignment on ISoundEffectPresetWidgetInterface");
static_assert(sizeof(ISoundEffectPresetWidgetInterface) == 0x000001, "Wrong size on ISoundEffectPresetWidgetInterface");

// Class Engine.AnimCurveCompressionCodec_UniformIndexable
// 0x0000 (0x0038 - 0x0038)
class UAnimCurveCompressionCodec_UniformIndexable final : public UAnimCurveCompressionCodec
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AnimCurveCompressionCodec_UniformIndexable">();
	}
	static class UAnimCurveCompressionCodec_UniformIndexable* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAnimCurveCompressionCodec_UniformIndexable>();
	}
};
static_assert(alignof(UAnimCurveCompressionCodec_UniformIndexable) == 0x000008, "Wrong alignment on UAnimCurveCompressionCodec_UniformIndexable");
static_assert(sizeof(UAnimCurveCompressionCodec_UniformIndexable) == 0x000038, "Wrong size on UAnimCurveCompressionCodec_UniformIndexable");

// Class Engine.WorldPartitionHLODProvider
// 0x0000 (0x0000 - 0x0000)
class IWorldPartitionHLODProvider final
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"WorldPartitionHLODProvider">();
	}
	static class IWorldPartitionHLODProvider* GetDefaultObj()
	{
		return GetDefaultObjImpl<IWorldPartitionHLODProvider>();
	}

	class UObject* AsUObject()
	{
		return reinterpret_cast<UObject*>(this);
	}
	const class UObject* AsUObject() const
	{
		return reinterpret_cast<const UObject*>(this);
	}
};
static_assert(alignof(IWorldPartitionHLODProvider) == 0x000001, "Wrong alignment on IWorldPartitionHLODProvider");
static_assert(sizeof(IWorldPartitionHLODProvider) == 0x000001, "Wrong size on IWorldPartitionHLODProvider");

// Class Engine.SoundEffectSourcePreset
// 0x0000 (0x0068 - 0x0068)
class USoundEffectSourcePreset : public USoundEffectPreset
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"SoundEffectSourcePreset">();
	}
	static class USoundEffectSourcePreset* GetDefaultObj()
	{
		return GetDefaultObjImpl<USoundEffectSourcePreset>();
	}
};
static_assert(alignof(USoundEffectSourcePreset) == 0x000008, "Wrong alignment on USoundEffectSourcePreset");
static_assert(sizeof(USoundEffectSourcePreset) == 0x000068, "Wrong size on USoundEffectSourcePreset");

// Class Engine.SoundEffectSourcePresetChain
// 0x0018 (0x0040 - 0x0028)
class USoundEffectSourcePresetChain final : public UObject
{
public:
	TArray<struct FSourceEffectChainEntry>        Chain;                                             // 0x0028(0x0010)(Edit, ZeroConstructor, NativeAccessSpecifierPublic)
	uint8                                         bPlayEffectChainTails : 1;                         // 0x0038(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_39[0x7];                                       // 0x0039(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"SoundEffectSourcePresetChain">();
	}
	static class USoundEffectSourcePresetChain* GetDefaultObj()
	{
		return GetDefaultObjImpl<USoundEffectSourcePresetChain>();
	}
};
static_assert(alignof(USoundEffectSourcePresetChain) == 0x000008, "Wrong alignment on USoundEffectSourcePresetChain");
static_assert(sizeof(USoundEffectSourcePresetChain) == 0x000040, "Wrong size on USoundEffectSourcePresetChain");
static_assert(offsetof(USoundEffectSourcePresetChain, Chain) == 0x000028, "Member 'USoundEffectSourcePresetChain::Chain' has a wrong offset!");

// Class Engine.SoundGroups
// 0x0060 (0x0088 - 0x0028)
class USoundGroups final : public UObject
{
public:
	TArray<struct FSoundGroup>                    SoundGroupProfiles;                                // 0x0028(0x0010)(ZeroConstructor, Config, NativeAccessSpecifierPrivate)
	uint8                                         Pad_38[0x50];                                      // 0x0038(0x0050)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"SoundGroups">();
	}
	static class USoundGroups* GetDefaultObj()
	{
		return GetDefaultObjImpl<USoundGroups>();
	}
};
static_assert(alignof(USoundGroups) == 0x000008, "Wrong alignment on USoundGroups");
static_assert(sizeof(USoundGroups) == 0x000088, "Wrong size on USoundGroups");
static_assert(offsetof(USoundGroups, SoundGroupProfiles) == 0x000028, "Member 'USoundGroups::SoundGroupProfiles' has a wrong offset!");

// Class Engine.CameraModifier
// 0x0020 (0x0048 - 0x0028)
class UCameraModifier : public UObject
{
public:
	uint8                                         bDebug : 1;                                        // 0x0028(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bExclusive : 1;                                    // 0x0028(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, DisableEditOnInstance, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_29[0x3];                                       // 0x0029(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	uint8                                         Priority;                                          // 0x002C(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_2D[0x3];                                       // 0x002D(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	class APlayerCameraManager*                   CameraOwner;                                       // 0x0030(0x0008)(BlueprintVisible, BlueprintReadOnly, ZeroConstructor, Transient, NoDestructor, Protected, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	float                                         AlphaInTime;                                       // 0x0038(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	float                                         AlphaOutTime;                                      // 0x003C(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	float                                         Alpha;                                             // 0x0040(0x0004)(BlueprintVisible, BlueprintReadOnly, ZeroConstructor, Transient, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_44[0x4];                                       // 0x0044(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void BlueprintModifyCamera(float DeltaTime, const struct FVector& ViewLocation, const struct FRotator& ViewRotation, float FOV, struct FVector* NewViewLocation, struct FRotator* NewViewRotation, float* NewFOV);
	void BlueprintModifyPostProcess(float DeltaTime, float* PostProcessBlendWeight, struct FPostProcessSettings* PostProcessSettings);
	void DisableModifier(bool bImmediate);
	void EnableModifier();
	void OnCameraOwnerDestroyed(class AActor* InOwner);

	class AActor* GetViewTarget() const;
	bool IsDisabled() const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"CameraModifier">();
	}
	static class UCameraModifier* GetDefaultObj()
	{
		return GetDefaultObjImpl<UCameraModifier>();
	}
};
static_assert(alignof(UCameraModifier) == 0x000008, "Wrong alignment on UCameraModifier");
static_assert(sizeof(UCameraModifier) == 0x000048, "Wrong size on UCameraModifier");
static_assert(offsetof(UCameraModifier, Priority) == 0x00002C, "Member 'UCameraModifier::Priority' has a wrong offset!");
static_assert(offsetof(UCameraModifier, CameraOwner) == 0x000030, "Member 'UCameraModifier::CameraOwner' has a wrong offset!");
static_assert(offsetof(UCameraModifier, AlphaInTime) == 0x000038, "Member 'UCameraModifier::AlphaInTime' has a wrong offset!");
static_assert(offsetof(UCameraModifier, AlphaOutTime) == 0x00003C, "Member 'UCameraModifier::AlphaOutTime' has a wrong offset!");
static_assert(offsetof(UCameraModifier, Alpha) == 0x000040, "Member 'UCameraModifier::Alpha' has a wrong offset!");

// Class Engine.SoundNodeModulatorContinuous
// 0x0040 (0x0088 - 0x0048)
class USoundNodeModulatorContinuous final : public USoundNode
{
public:
	struct FModulatorContinuousParams             PitchModulationParams;                             // 0x0048(0x0020)(Edit, NoDestructor, NativeAccessSpecifierPublic)
	struct FModulatorContinuousParams             VolumeModulationParams;                            // 0x0068(0x0020)(Edit, NoDestructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"SoundNodeModulatorContinuous">();
	}
	static class USoundNodeModulatorContinuous* GetDefaultObj()
	{
		return GetDefaultObjImpl<USoundNodeModulatorContinuous>();
	}
};
static_assert(alignof(USoundNodeModulatorContinuous) == 0x000008, "Wrong alignment on USoundNodeModulatorContinuous");
static_assert(sizeof(USoundNodeModulatorContinuous) == 0x000088, "Wrong size on USoundNodeModulatorContinuous");
static_assert(offsetof(USoundNodeModulatorContinuous, PitchModulationParams) == 0x000048, "Member 'USoundNodeModulatorContinuous::PitchModulationParams' has a wrong offset!");
static_assert(offsetof(USoundNodeModulatorContinuous, VolumeModulationParams) == 0x000068, "Member 'USoundNodeModulatorContinuous::VolumeModulationParams' has a wrong offset!");

// Class Engine.SoundSubmixWidgetInterface
// 0x0000 (0x0000 - 0x0000)
class ISoundSubmixWidgetInterface final
{
public:
	void OnConstructed(class USoundSubmixBase* SoundSubmix);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"SoundSubmixWidgetInterface">();
	}
	static class ISoundSubmixWidgetInterface* GetDefaultObj()
	{
		return GetDefaultObjImpl<ISoundSubmixWidgetInterface>();
	}

	class UObject* AsUObject()
	{
		return reinterpret_cast<UObject*>(this);
	}
	const class UObject* AsUObject() const
	{
		return reinterpret_cast<const UObject*>(this);
	}
};
static_assert(alignof(ISoundSubmixWidgetInterface) == 0x000001, "Wrong alignment on ISoundSubmixWidgetInterface");
static_assert(sizeof(ISoundSubmixWidgetInterface) == 0x000001, "Wrong size on ISoundSubmixWidgetInterface");

// Class Engine.HLODLayer
// 0x0040 (0x0068 - 0x0028)
class UHLODLayer final : public UObject
{
public:
	EHLODLayerType                                LayerType;                                         // 0x0028(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_29[0x7];                                       // 0x0029(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	TSubclassOf<class UHLODBuilder>               HLODBuilderClass;                                  // 0x0030(0x0008)(Edit, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	class UHLODBuilderSettings*                   HLODBuilderSettings;                               // 0x0038(0x0008)(Edit, ExportObject, ZeroConstructor, EditConst, NoClear, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         bIsSpatiallyLoaded : 1;                            // 0x0040(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate))
	uint8                                         Pad_41[0x3];                                       // 0x0041(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	int32                                         CellSize;                                          // 0x0044(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	double                                        LoadingRange;                                      // 0x0048(0x0008)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	class UHLODLayer*                             ParentLayer;                                       // 0x0050(0x0008)(Edit, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	TSubclassOf<class AWorldPartitionHLOD>        HLODActorClass;                                    // 0x0058(0x0008)(Edit, ZeroConstructor, NoDestructor, AdvancedDisplay, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	TSubclassOf<class UWorldPartitionHLODModifier> HLODModifierClass;                                // 0x0060(0x0008)(Edit, ZeroConstructor, NoDestructor, AdvancedDisplay, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"HLODLayer">();
	}
	static class UHLODLayer* GetDefaultObj()
	{
		return GetDefaultObjImpl<UHLODLayer>();
	}
};
static_assert(alignof(UHLODLayer) == 0x000008, "Wrong alignment on UHLODLayer");
static_assert(sizeof(UHLODLayer) == 0x000068, "Wrong size on UHLODLayer");
static_assert(offsetof(UHLODLayer, LayerType) == 0x000028, "Member 'UHLODLayer::LayerType' has a wrong offset!");
static_assert(offsetof(UHLODLayer, HLODBuilderClass) == 0x000030, "Member 'UHLODLayer::HLODBuilderClass' has a wrong offset!");
static_assert(offsetof(UHLODLayer, HLODBuilderSettings) == 0x000038, "Member 'UHLODLayer::HLODBuilderSettings' has a wrong offset!");
static_assert(offsetof(UHLODLayer, CellSize) == 0x000044, "Member 'UHLODLayer::CellSize' has a wrong offset!");
static_assert(offsetof(UHLODLayer, LoadingRange) == 0x000048, "Member 'UHLODLayer::LoadingRange' has a wrong offset!");
static_assert(offsetof(UHLODLayer, ParentLayer) == 0x000050, "Member 'UHLODLayer::ParentLayer' has a wrong offset!");
static_assert(offsetof(UHLODLayer, HLODActorClass) == 0x000058, "Member 'UHLODLayer::HLODActorClass' has a wrong offset!");
static_assert(offsetof(UHLODLayer, HLODModifierClass) == 0x000060, "Member 'UHLODLayer::HLODModifierClass' has a wrong offset!");

// Class Engine.SparseVolumeTexture
// 0x0000 (0x0028 - 0x0028)
class USparseVolumeTexture : public UObject
{
public:
	int32 GetNumFrames() const;
	int32 GetNumMipLevels() const;
	int32 GetSizeX() const;
	int32 GetSizeY() const;
	int32 GetSizeZ() const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"SparseVolumeTexture">();
	}
	static class USparseVolumeTexture* GetDefaultObj()
	{
		return GetDefaultObjImpl<USparseVolumeTexture>();
	}
};
static_assert(alignof(USparseVolumeTexture) == 0x000008, "Wrong alignment on USparseVolumeTexture");
static_assert(sizeof(USparseVolumeTexture) == 0x000028, "Wrong size on USparseVolumeTexture");

// Class Engine.SparseVolumeTextureFrame
// 0x00E8 (0x0110 - 0x0028)
class alignas(0x10) USparseVolumeTextureFrame final : public USparseVolumeTexture
{
public:
	class USparseVolumeTexture*                   Owner;                                             // 0x0028(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	int32                                         FrameIndex;                                        // 0x0030(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_34[0xDC];                                      // 0x0034(0x00DC)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"SparseVolumeTextureFrame">();
	}
	static class USparseVolumeTextureFrame* GetDefaultObj()
	{
		return GetDefaultObjImpl<USparseVolumeTextureFrame>();
	}
};
static_assert(alignof(USparseVolumeTextureFrame) == 0x000010, "Wrong alignment on USparseVolumeTextureFrame");
static_assert(sizeof(USparseVolumeTextureFrame) == 0x000110, "Wrong size on USparseVolumeTextureFrame");
static_assert(offsetof(USparseVolumeTextureFrame, Owner) == 0x000028, "Member 'USparseVolumeTextureFrame::Owner' has a wrong offset!");
static_assert(offsetof(USparseVolumeTextureFrame, FrameIndex) == 0x000030, "Member 'USparseVolumeTextureFrame::FrameIndex' has a wrong offset!");

// Class Engine.CameraShakeSourceActor
// 0x0008 (0x02A8 - 0x02A0)
class ACameraShakeSourceActor final : public AActor
{
public:
	class UCameraShakeSourceComponent*            CameraShakeSourceComponent;                        // 0x02A0(0x0008)(Edit, BlueprintVisible, ExportObject, BlueprintReadOnly, ZeroConstructor, EditConst, InstancedReference, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"CameraShakeSourceActor">();
	}
	static class ACameraShakeSourceActor* GetDefaultObj()
	{
		return GetDefaultObjImpl<ACameraShakeSourceActor>();
	}
};
static_assert(alignof(ACameraShakeSourceActor) == 0x000008, "Wrong alignment on ACameraShakeSourceActor");
static_assert(sizeof(ACameraShakeSourceActor) == 0x0002A8, "Wrong size on ACameraShakeSourceActor");
static_assert(offsetof(ACameraShakeSourceActor, CameraShakeSourceComponent) == 0x0002A0, "Member 'ACameraShakeSourceActor::CameraShakeSourceComponent' has a wrong offset!");

// Class Engine.StreamableSparseVolumeTexture
// 0x0058 (0x0080 - 0x0028)
class UStreamableSparseVolumeTexture : public USparseVolumeTexture
{
public:
	struct FIntVector                             VolumeResolution;                                  // 0x0028(0x000C)(Edit, ZeroConstructor, EditConst, IsPlainOldData, NoDestructor, AssetRegistrySearchable, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         NumMipLevels;                                      // 0x0034(0x0004)(Edit, ZeroConstructor, EditConst, IsPlainOldData, NoDestructor, AssetRegistrySearchable, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         NumFrames;                                         // 0x0038(0x0004)(Edit, ZeroConstructor, EditConst, IsPlainOldData, NoDestructor, AssetRegistrySearchable, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EPixelFormat                                  FormatA;                                           // 0x003C(0x0001)(Edit, ZeroConstructor, EditConst, IsPlainOldData, NoDestructor, AssetRegistrySearchable, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EPixelFormat                                  FormatB;                                           // 0x003D(0x0001)(Edit, ZeroConstructor, EditConst, IsPlainOldData, NoDestructor, AssetRegistrySearchable, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_3E[0x2];                                       // 0x003E(0x0002)(Fixing Size After Last Property [ Dumper-7 ])
	struct FVector4f                              FallbackValueA;                                    // 0x0040(0x0010)(Edit, ZeroConstructor, EditConst, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector4f                              FallbackValueB;                                    // 0x0050(0x0010)(Edit, ZeroConstructor, EditConst, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	ETextureAddress                               AddressX;                                          // 0x0060(0x0001)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, AssetRegistrySearchable, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	ETextureAddress                               AddressY;                                          // 0x0061(0x0001)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, AssetRegistrySearchable, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	ETextureAddress                               AddressZ;                                          // 0x0062(0x0001)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, AssetRegistrySearchable, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bLocalDDCOnly;                                     // 0x0063(0x0001)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_64[0x4];                                       // 0x0064(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<class USparseVolumeTextureFrame*>      Frames;                                            // 0x0068(0x0010)(ExportObject, ZeroConstructor, Protected, UObjectWrapper, NativeAccessSpecifierProtected)
	uint8                                         Pad_78[0x8];                                       // 0x0078(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"StreamableSparseVolumeTexture">();
	}
	static class UStreamableSparseVolumeTexture* GetDefaultObj()
	{
		return GetDefaultObjImpl<UStreamableSparseVolumeTexture>();
	}
};
static_assert(alignof(UStreamableSparseVolumeTexture) == 0x000010, "Wrong alignment on UStreamableSparseVolumeTexture");
static_assert(sizeof(UStreamableSparseVolumeTexture) == 0x000080, "Wrong size on UStreamableSparseVolumeTexture");
static_assert(offsetof(UStreamableSparseVolumeTexture, VolumeResolution) == 0x000028, "Member 'UStreamableSparseVolumeTexture::VolumeResolution' has a wrong offset!");
static_assert(offsetof(UStreamableSparseVolumeTexture, NumMipLevels) == 0x000034, "Member 'UStreamableSparseVolumeTexture::NumMipLevels' has a wrong offset!");
static_assert(offsetof(UStreamableSparseVolumeTexture, NumFrames) == 0x000038, "Member 'UStreamableSparseVolumeTexture::NumFrames' has a wrong offset!");
static_assert(offsetof(UStreamableSparseVolumeTexture, FormatA) == 0x00003C, "Member 'UStreamableSparseVolumeTexture::FormatA' has a wrong offset!");
static_assert(offsetof(UStreamableSparseVolumeTexture, FormatB) == 0x00003D, "Member 'UStreamableSparseVolumeTexture::FormatB' has a wrong offset!");
static_assert(offsetof(UStreamableSparseVolumeTexture, FallbackValueA) == 0x000040, "Member 'UStreamableSparseVolumeTexture::FallbackValueA' has a wrong offset!");
static_assert(offsetof(UStreamableSparseVolumeTexture, FallbackValueB) == 0x000050, "Member 'UStreamableSparseVolumeTexture::FallbackValueB' has a wrong offset!");
static_assert(offsetof(UStreamableSparseVolumeTexture, AddressX) == 0x000060, "Member 'UStreamableSparseVolumeTexture::AddressX' has a wrong offset!");
static_assert(offsetof(UStreamableSparseVolumeTexture, AddressY) == 0x000061, "Member 'UStreamableSparseVolumeTexture::AddressY' has a wrong offset!");
static_assert(offsetof(UStreamableSparseVolumeTexture, AddressZ) == 0x000062, "Member 'UStreamableSparseVolumeTexture::AddressZ' has a wrong offset!");
static_assert(offsetof(UStreamableSparseVolumeTexture, bLocalDDCOnly) == 0x000063, "Member 'UStreamableSparseVolumeTexture::bLocalDDCOnly' has a wrong offset!");
static_assert(offsetof(UStreamableSparseVolumeTexture, Frames) == 0x000068, "Member 'UStreamableSparseVolumeTexture::Frames' has a wrong offset!");

// Class Engine.StaticSparseVolumeTexture
// 0x0000 (0x0080 - 0x0080)
class UStaticSparseVolumeTexture final : public UStreamableSparseVolumeTexture
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"StaticSparseVolumeTexture">();
	}
	static class UStaticSparseVolumeTexture* GetDefaultObj()
	{
		return GetDefaultObjImpl<UStaticSparseVolumeTexture>();
	}
};
static_assert(alignof(UStaticSparseVolumeTexture) == 0x000010, "Wrong alignment on UStaticSparseVolumeTexture");
static_assert(sizeof(UStaticSparseVolumeTexture) == 0x000080, "Wrong size on UStaticSparseVolumeTexture");

// Class Engine.AnimatedSparseVolumeTexture
// 0x0000 (0x0080 - 0x0080)
class UAnimatedSparseVolumeTexture final : public UStreamableSparseVolumeTexture
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AnimatedSparseVolumeTexture">();
	}
	static class UAnimatedSparseVolumeTexture* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAnimatedSparseVolumeTexture>();
	}
};
static_assert(alignof(UAnimatedSparseVolumeTexture) == 0x000010, "Wrong alignment on UAnimatedSparseVolumeTexture");
static_assert(sizeof(UAnimatedSparseVolumeTexture) == 0x000080, "Wrong size on UAnimatedSparseVolumeTexture");

// Class Engine.AnimatedSparseVolumeTextureController
// 0x0020 (0x0048 - 0x0028)
class UAnimatedSparseVolumeTextureController final : public UObject
{
public:
	class USparseVolumeTexture*                   SparseVolumeTexture;                               // 0x0028(0x0008)(BlueprintVisible, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         Time;                                              // 0x0030(0x0004)(BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bIsPlaying;                                        // 0x0034(0x0001)(BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_35[0x3];                                       // 0x0035(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         FrameRate;                                         // 0x0038(0x0004)(BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         MipLevel;                                          // 0x003C(0x0004)(BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bBlockingStreamingRequests;                        // 0x0040(0x0001)(BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_41[0x7];                                       // 0x0041(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	class USparseVolumeTextureFrame* GetCurrentFrame();
	void GetCurrentFramesForInterpolation(class USparseVolumeTextureFrame** Frame0, class USparseVolumeTextureFrame** Frame1, float* LerpAlpha);
	float GetDuration();
	float GetFractionalFrameIndex();
	class USparseVolumeTextureFrame* GetFrameByIndex(int32 FrameIndex);
	void Pause();
	void Play();
	void Stop();
	void Update(float DeltaTime);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AnimatedSparseVolumeTextureController">();
	}
	static class UAnimatedSparseVolumeTextureController* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAnimatedSparseVolumeTextureController>();
	}
};
static_assert(alignof(UAnimatedSparseVolumeTextureController) == 0x000008, "Wrong alignment on UAnimatedSparseVolumeTextureController");
static_assert(sizeof(UAnimatedSparseVolumeTextureController) == 0x000048, "Wrong size on UAnimatedSparseVolumeTextureController");
static_assert(offsetof(UAnimatedSparseVolumeTextureController, SparseVolumeTexture) == 0x000028, "Member 'UAnimatedSparseVolumeTextureController::SparseVolumeTexture' has a wrong offset!");
static_assert(offsetof(UAnimatedSparseVolumeTextureController, Time) == 0x000030, "Member 'UAnimatedSparseVolumeTextureController::Time' has a wrong offset!");
static_assert(offsetof(UAnimatedSparseVolumeTextureController, bIsPlaying) == 0x000034, "Member 'UAnimatedSparseVolumeTextureController::bIsPlaying' has a wrong offset!");
static_assert(offsetof(UAnimatedSparseVolumeTextureController, FrameRate) == 0x000038, "Member 'UAnimatedSparseVolumeTextureController::FrameRate' has a wrong offset!");
static_assert(offsetof(UAnimatedSparseVolumeTextureController, MipLevel) == 0x00003C, "Member 'UAnimatedSparseVolumeTextureController::MipLevel' has a wrong offset!");
static_assert(offsetof(UAnimatedSparseVolumeTextureController, bBlockingStreamingRequests) == 0x000040, "Member 'UAnimatedSparseVolumeTextureController::bBlockingStreamingRequests' has a wrong offset!");

// Class Engine.CanvasRenderTarget2D
// 0x0020 (0x0220 - 0x0200)
class UCanvasRenderTarget2D final : public UTextureRenderTarget2D
{
public:
	TMulticastInlineDelegate<void(class UCanvas* Canvas, int32 Width, int32 Height)> OnCanvasRenderTargetUpdate; // 0x01F8(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	TWeakObjectPtr<class UWorld>                  World;                                             // 0x0208(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, Protected, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	bool                                          bShouldClearRenderTargetOnReceiveUpdate;           // 0x0210(0x0001)(ZeroConstructor, Transient, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_211[0xF];                                      // 0x0211(0x000F)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UCanvasRenderTarget2D* CreateCanvasRenderTarget2D(class UObject* WorldContextObject, TSubclassOf<class UCanvasRenderTarget2D> CanvasRenderTarget2DClass, int32 Width, int32 Height);

	void GetSize(int32* Width, int32* Height);
	void ReceiveUpdate(class UCanvas* Canvas, int32 Width, int32 Height);
	void UpdateResource();

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"CanvasRenderTarget2D">();
	}
	static class UCanvasRenderTarget2D* GetDefaultObj()
	{
		return GetDefaultObjImpl<UCanvasRenderTarget2D>();
	}
};
static_assert(alignof(UCanvasRenderTarget2D) == 0x000010, "Wrong alignment on UCanvasRenderTarget2D");
static_assert(sizeof(UCanvasRenderTarget2D) == 0x000220, "Wrong size on UCanvasRenderTarget2D");
static_assert(offsetof(UCanvasRenderTarget2D, OnCanvasRenderTargetUpdate) == 0x0001F8, "Member 'UCanvasRenderTarget2D::OnCanvasRenderTargetUpdate' has a wrong offset!");
static_assert(offsetof(UCanvasRenderTarget2D, World) == 0x000208, "Member 'UCanvasRenderTarget2D::World' has a wrong offset!");
static_assert(offsetof(UCanvasRenderTarget2D, bShouldClearRenderTargetOnReceiveUpdate) == 0x000210, "Member 'UCanvasRenderTarget2D::bShouldClearRenderTargetOnReceiveUpdate' has a wrong offset!");

// Class Engine.SphereReflectionCapture
// 0x0008 (0x02B0 - 0x02A8)
class ASphereReflectionCapture final : public AReflectionCapture
{
public:
	class UDrawSphereComponent*                   DrawCaptureRadius;                                 // 0x02A8(0x0008)(ExportObject, ZeroConstructor, InstancedReference, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"SphereReflectionCapture">();
	}
	static class ASphereReflectionCapture* GetDefaultObj()
	{
		return GetDefaultObjImpl<ASphereReflectionCapture>();
	}
};
static_assert(alignof(ASphereReflectionCapture) == 0x000008, "Wrong alignment on ASphereReflectionCapture");
static_assert(sizeof(ASphereReflectionCapture) == 0x0002B0, "Wrong size on ASphereReflectionCapture");
static_assert(offsetof(ASphereReflectionCapture, DrawCaptureRadius) == 0x0002A8, "Member 'ASphereReflectionCapture::DrawCaptureRadius' has a wrong offset!");

// Class Engine.SphereReflectionCaptureComponent
// 0x0010 (0x0320 - 0x0310)
class USphereReflectionCaptureComponent final : public UReflectionCaptureComponent
{
public:
	float                                         InfluenceRadius;                                   // 0x0310(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         CaptureDistanceScale;                              // 0x0314(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UDrawSphereComponent*                   PreviewInfluenceRadius;                            // 0x0318(0x0008)(ExportObject, ZeroConstructor, InstancedReference, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"SphereReflectionCaptureComponent">();
	}
	static class USphereReflectionCaptureComponent* GetDefaultObj()
	{
		return GetDefaultObjImpl<USphereReflectionCaptureComponent>();
	}
};
static_assert(alignof(USphereReflectionCaptureComponent) == 0x000010, "Wrong alignment on USphereReflectionCaptureComponent");
static_assert(sizeof(USphereReflectionCaptureComponent) == 0x000320, "Wrong size on USphereReflectionCaptureComponent");
static_assert(offsetof(USphereReflectionCaptureComponent, InfluenceRadius) == 0x000310, "Member 'USphereReflectionCaptureComponent::InfluenceRadius' has a wrong offset!");
static_assert(offsetof(USphereReflectionCaptureComponent, CaptureDistanceScale) == 0x000314, "Member 'USphereReflectionCaptureComponent::CaptureDistanceScale' has a wrong offset!");
static_assert(offsetof(USphereReflectionCaptureComponent, PreviewInfluenceRadius) == 0x000318, "Member 'USphereReflectionCaptureComponent::PreviewInfluenceRadius' has a wrong offset!");

// Class Engine.StaticMeshSocket
// 0x0060 (0x0088 - 0x0028)
class UStaticMeshSocket final : public UObject
{
public:
	class FName                                   SocketName;                                        // 0x0028(0x0008)(BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector                                RelativeLocation;                                  // 0x0030(0x0018)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FRotator                               RelativeRotation;                                  // 0x0048(0x0018)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
	struct FVector                                RelativeScale;                                     // 0x0060(0x0018)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FString                                 Tag;                                               // 0x0078(0x0010)(Edit, BlueprintVisible, ZeroConstructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"StaticMeshSocket">();
	}
	static class UStaticMeshSocket* GetDefaultObj()
	{
		return GetDefaultObjImpl<UStaticMeshSocket>();
	}
};
static_assert(alignof(UStaticMeshSocket) == 0x000008, "Wrong alignment on UStaticMeshSocket");
static_assert(sizeof(UStaticMeshSocket) == 0x000088, "Wrong size on UStaticMeshSocket");
static_assert(offsetof(UStaticMeshSocket, SocketName) == 0x000028, "Member 'UStaticMeshSocket::SocketName' has a wrong offset!");
static_assert(offsetof(UStaticMeshSocket, RelativeLocation) == 0x000030, "Member 'UStaticMeshSocket::RelativeLocation' has a wrong offset!");
static_assert(offsetof(UStaticMeshSocket, RelativeRotation) == 0x000048, "Member 'UStaticMeshSocket::RelativeRotation' has a wrong offset!");
static_assert(offsetof(UStaticMeshSocket, RelativeScale) == 0x000060, "Member 'UStaticMeshSocket::RelativeScale' has a wrong offset!");
static_assert(offsetof(UStaticMeshSocket, Tag) == 0x000078, "Member 'UStaticMeshSocket::Tag' has a wrong offset!");

// Class Engine.StereoLayerShape
// 0x0000 (0x0028 - 0x0028)
class UStereoLayerShape : public UObject
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"StereoLayerShape">();
	}
	static class UStereoLayerShape* GetDefaultObj()
	{
		return GetDefaultObjImpl<UStereoLayerShape>();
	}
};
static_assert(alignof(UStereoLayerShape) == 0x000008, "Wrong alignment on UStereoLayerShape");
static_assert(sizeof(UStereoLayerShape) == 0x000028, "Wrong size on UStereoLayerShape");

// Class Engine.PlayerController
// 0x0528 (0x0860 - 0x0338)
class APlayerController : public AController
{
public:
	uint8                                         Pad_338[0x8];                                      // 0x0338(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	class UPlayer*                                Player;                                            // 0x0340(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class APawn*                                  AcknowledgedPawn;                                  // 0x0348(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AHUD*                                   MyHUD;                                             // 0x0350(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class APlayerCameraManager*                   PlayerCameraManager;                               // 0x0358(0x0008)(BlueprintVisible, BlueprintReadOnly, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TSubclassOf<class APlayerCameraManager>       PlayerCameraManagerClass;                          // 0x0360(0x0008)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bAutoManageActiveCameraTarget;                     // 0x0368(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_369[0x7];                                      // 0x0369(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	struct FRotator                               TargetViewRotation;                                // 0x0370(0x0018)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
	uint8                                         Pad_388[0x18];                                     // 0x0388(0x0018)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         SmoothTargetViewRotationSpeed;                     // 0x03A0(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_3A4[0x4];                                      // 0x03A4(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<class AActor*>                         HiddenActors;                                      // 0x03A8(0x0010)(ZeroConstructor, UObjectWrapper, NativeAccessSpecifierPublic)
	TArray<TWeakObjectPtr<class UPrimitiveComponent>> HiddenPrimitiveComponents;                     // 0x03B8(0x0010)(ExportObject, ZeroConstructor, ContainsInstancedReference, UObjectWrapper, NativeAccessSpecifierPublic)
	uint8                                         Pad_3C8[0x4];                                      // 0x03C8(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         LastSpectatorStateSynchTime;                       // 0x03CC(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector                                LastSpectatorSyncLocation;                         // 0x03D0(0x0018)(ZeroConstructor, Transient, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FRotator                               LastSpectatorSyncRotation;                         // 0x03E8(0x0018)(ZeroConstructor, Transient, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
	int32                                         ClientCap;                                         // 0x0400(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_404[0x4];                                      // 0x0404(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	class UCheatManager*                          CheatManager;                                      // 0x0408(0x0008)(BlueprintVisible, BlueprintReadOnly, ZeroConstructor, Transient, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TSubclassOf<class UCheatManager>              CheatClass;                                        // 0x0410(0x0008)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, DisableEditOnInstance, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UPlayerInput*                           PlayerInput;                                       // 0x0418(0x0008)(ZeroConstructor, Transient, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TArray<struct FActiveForceFeedbackEffect>     ActiveForceFeedbackEffects;                        // 0x0420(0x0010)(ZeroConstructor, Transient, NativeAccessSpecifierPublic)
	TSubclassOf<class UAsyncPhysicsData>          AsyncPhysicsDataClass;                             // 0x0430(0x0008)(ZeroConstructor, Deprecated, NoDestructor, Protected, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	class UAsyncPhysicsInputComponent*            AsyncPhysicsDataComponent_DEPRECARED;              // 0x0438(0x0008)(ExportObject, Net, ZeroConstructor, InstancedReference, RepNotify, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_440[0x80];                                     // 0x0440(0x0080)(Fixing Size After Last Property [ Dumper-7 ])
	uint8                                         BitPad_4C0_0 : 4;                                  // 0x04C0(0x0001)(Fixing Bit-Field Size Between Bits [ Dumper-7 ])
	uint8                                         bPlayerIsWaiting : 1;                              // 0x04C0(0x0001)(BitIndex: 0x04, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, DisableEditOnTemplate, EditConst, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_4C1[0x3];                                      // 0x04C1(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	uint8                                         NetPlayerIndex;                                    // 0x04C4(0x0001)(ZeroConstructor, DuplicateTransient, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_4C5[0x5B];                                     // 0x04C5(0x005B)(Fixing Size After Last Property [ Dumper-7 ])
	class UNetConnection*                         PendingSwapConnection;                             // 0x0520(0x0008)(ZeroConstructor, DuplicateTransient, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UNetConnection*                         NetConnection;                                     // 0x0528(0x0008)(ZeroConstructor, DuplicateTransient, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_530[0x18];                                     // 0x0530(0x0018)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         InputYawScale;                                     // 0x0548(0x0004)(ZeroConstructor, Config, Deprecated, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         InputPitchScale;                                   // 0x054C(0x0004)(ZeroConstructor, Config, Deprecated, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         InputRollScale;                                    // 0x0550(0x0004)(ZeroConstructor, Config, Deprecated, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bShowMouseCursor : 1;                              // 0x0554(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bEnableClickEvents : 1;                            // 0x0554(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bEnableTouchEvents : 1;                            // 0x0554(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bEnableMouseOverEvents : 1;                        // 0x0554(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bEnableTouchOverEvents : 1;                        // 0x0554(0x0001)(BitIndex: 0x04, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bForceFeedbackEnabled : 1;                         // 0x0554(0x0001)(BitIndex: 0x05, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bEnableMotionControls : 1;                         // 0x0554(0x0001)(BitIndex: 0x06, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bEnableStreamingSource : 1;                        // 0x0554(0x0001)(BitIndex: 0x07, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bStreamingSourceShouldActivate : 1;                // 0x0555(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bStreamingSourceShouldBlockOnSlowStreaming : 1;    // 0x0555(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_556[0x2];                                      // 0x0556(0x0002)(Fixing Size After Last Property [ Dumper-7 ])
	EStreamingSourcePriority                      StreamingSourcePriority;                           // 0x0558(0x0001)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_559[0x3];                                      // 0x0559(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	struct FColor                                 StreamingSourceDebugColor;                         // 0x055C(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TArray<struct FStreamingSourceShape>          StreamingSourceShapes;                             // 0x0560(0x0010)(Edit, BlueprintVisible, ZeroConstructor, NativeAccessSpecifierPublic)
	float                                         ForceFeedbackScale;                                // 0x0570(0x0004)(ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_574[0x4];                                      // 0x0574(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<struct FKey>                           ClickEventKeys;                                    // 0x0578(0x0010)(Edit, BlueprintVisible, ZeroConstructor, NativeAccessSpecifierPublic)
	EMouseCursor                                  DefaultMouseCursor;                                // 0x0588(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EMouseCursor                                  CurrentMouseCursor;                                // 0x0589(0x0001)(BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	ECollisionChannel                             DefaultClickTraceChannel;                          // 0x058A(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	ECollisionChannel                             CurrentClickTraceChannel;                          // 0x058B(0x0001)(BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         HitResultTraceDistance;                            // 0x058C(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint16                                        SeamlessTravelCount;                               // 0x0590(0x0002)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint16                                        LastCompletedSeamlessTravelCount;                  // 0x0592(0x0002)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_594[0x84];                                     // 0x0594(0x0084)(Fixing Size After Last Property [ Dumper-7 ])
	class UInputComponent*                        InactiveStateInputComponent;                       // 0x0618(0x0008)(ExportObject, ZeroConstructor, InstancedReference, NoDestructor, Protected, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         BitPad_620_0 : 2;                                  // 0x0620(0x0001)(Fixing Bit-Field Size Between Bits [ Dumper-7 ])
	uint8                                         bShouldPerformFullTickWhenPaused : 1;              // 0x0620(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
	uint8                                         Pad_621[0x17];                                     // 0x0621(0x0017)(Fixing Size After Last Property [ Dumper-7 ])
	class UTouchInterface*                        CurrentTouchInterface;                             // 0x0638(0x0008)(ZeroConstructor, NoDestructor, Protected, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	TSubclassOf<class UPlayerInput>               OverridePlayerInputClass;                          // 0x0640(0x0008)(Edit, ZeroConstructor, DisableEditOnInstance, NoDestructor, Protected, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_648[0x78];                                     // 0x0648(0x0078)(Fixing Size After Last Property [ Dumper-7 ])
	class ASpectatorPawn*                         SpectatorPawn;                                     // 0x06C0(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_6C8[0x4];                                      // 0x06C8(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	bool                                          bIsLocalPlayerController;                          // 0x06CC(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_6CD[0x3];                                      // 0x06CD(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	struct FVector                                SpawnLocation;                                     // 0x06D0(0x0018)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_6E8[0x178];                                    // 0x06E8(0x0178)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void ActivateTouchInterface(class UTouchInterface* NewTouchInterface);
	void AddPitchInput(float val);
	void AddRollInput(float val);
	void AddYawInput(float val);
	void Camera(class FName NewMode);
	bool CanRestartPlayer();
	void ClearAudioListenerAttenuationOverride();
	void ClearAudioListenerOverride();
	void ClientAckTimeDilation(float TimeDilation, int32 ServerStep);
	void ClientAckUpdateLevelVisibility(class FName PackageName, const struct FNetLevelVisibilityTransactionId& TransactionId, bool bClientAckCanMakeVisible);
	void ClientAddTextureStreamingLoc(const struct FVector& InLoc, float Duration, bool bOverrideLocation);
	void ClientCancelPendingMapChange();
	void ClientCapBandwidth(int32 Cap);
	void ClientClearCameraLensEffects();
	void ClientCommitMapChange();
	void ClientCorrectionAsyncPhysicsTimestamp(const struct FAsyncPhysicsTimestamp& Timestamp);
	void ClientEnableNetworkVoice(bool bEnable);
	void ClientEndOnlineSession();
	void ClientFlushLevelStreaming();
	void ClientForceGarbageCollection();
	void ClientGameEnded(class AActor* EndGameFocus, bool bIsWinner);
	void ClientGotoState(class FName NewState);
	void ClientIgnoreLookInput(bool bIgnore);
	void ClientIgnoreMoveInput(bool bIgnore);
	void ClientMessage(const class FString& S, class FName Type, float MsgLifeTime);
	void ClientMutePlayer(const struct FUniqueNetIdRepl& PlayerId);
	void ClientPlayForceFeedback_Internal(class UForceFeedbackEffect* ForceFeedbackEffect, const struct FForceFeedbackParameters& params);
	void ClientPlaySound(class USoundBase* Sound, float VolumeMultiplier, float PitchMultiplier);
	void ClientPlaySoundAtLocation(class USoundBase* Sound, const struct FVector& Location, float VolumeMultiplier, float PitchMultiplier);
	void ClientPrepareMapChange(class FName LevelName, bool bFirst, bool Blast);
	void ClientPrestreamTextures(class AActor* ForcedActor, float ForceDuration, bool bEnableStreaming, int32 CinematicTextureGroups);
	void ClientReceiveLocalizedMessage(TSubclassOf<class ULocalMessage> Message, int32 SWITCH, class APlayerState* RelatedPlayerState_1, class APlayerState* RelatedPlayerState_2, class UObject* OptionalObject);
	void ClientRecvServerAckFrame(int32 LastProcessedInputFrame, int32 RecvServerFrameNumber, int8 TimeDilation);
	void ClientRecvServerAckFrameDebug(uint8 NumBuffered, float TargetNumBufferedCmds);
	void ClientRepObjRef(class UObject* Object);
	void ClientReset();
	void ClientRestart(class APawn* NewPawn);
	void ClientRetryClientRestart(class APawn* NewPawn);
	void ClientReturnToMainMenuWithTextReason(const class FText& ReturnReason);
	void ClientSetBlockOnAsyncLoading();
	void ClientSetCameraFade(bool bEnableFading, const struct FColor& FadeColor, const struct FVector2D& FadeAlpha, float FadeTime, bool bFadeAudio, bool bHoldWhenFinished);
	void ClientSetCameraMode(class FName NewCamMode);
	void ClientSetCinematicMode(bool bInCinematicMode, bool bAffectsMovement, bool bAffectsTurning, bool bAffectsHUD);
	void ClientSetForceMipLevelsToBeResident(class UMaterialInterface* Material, float ForceDuration, int32 CinematicTextureGroups);
	void ClientSetHUD(TSubclassOf<class AHUD> NewHUDClass);
	void ClientSetSpectatorWaiting(bool bWaiting);
	void ClientSetViewTarget(class AActor* A, const struct FViewTargetTransitionParams& TransitionParams);
	void ClientSpawnCameraLensEffect(TSubclassOf<class AEmitterCameraLensEffectBase> LensEffectEmitterClass);
	void ClientSpawnGenericCameraLensEffect(TSubclassOf<class AActor> LensEffectEmitterClass);
	void ClientStartCameraShake(TSubclassOf<class UCameraShakeBase> Shake, float Scale, ECameraShakePlaySpace PlaySpace, const struct FRotator& UserPlaySpaceRot);
	void ClientStartCameraShakeFromSource(TSubclassOf<class UCameraShakeBase> Shake, class UCameraShakeSourceComponent* SourceComponent);
	void ClientStartOnlineSession();
	void ClientStopCameraShake(TSubclassOf<class UCameraShakeBase> Shake, bool bImmediately);
	void ClientStopCameraShakesFromSource(class UCameraShakeSourceComponent* SourceComponent, bool bImmediately);
	void ClientStopForceFeedback(class UForceFeedbackEffect* ForceFeedbackEffect, class FName Tag);
	void ClientTeamMessage(class APlayerState* SenderPlayerState, const class FString& S, class FName Type, float MsgLifeTime);
	void ClientTravel(const class FString& URL, ETravelType TravelType, bool bSeamless, const struct FGuid& MapPackageGuid);
	void ClientTravelInternal(const class FString& URL, ETravelType TravelType, bool bSeamless, const struct FGuid& MapPackageGuid);
	void ClientUnmutePlayer(const struct FUniqueNetIdRepl& PlayerId);
	void ClientUnmutePlayers(const TArray<struct FUniqueNetIdRepl>& PlayerIds);
	void ClientUpdateLevelStreamingStatus(class FName PackageName, bool bNewShouldBeLoaded, bool bNewShouldBeVisible, bool bNewShouldBlockOnLoad, int32 LODIndex, const struct FNetLevelVisibilityTransactionId& TransactionId, bool bNewShouldBlockOnUnload);
	void ClientUpdateMultipleLevelsStreamingStatus(const TArray<struct FUpdateLevelStreamingLevelStatus>& LevelStatuses);
	void ClientVoiceHandshakeComplete();
	void ClientWasKicked(const class FText& KickReason);
	void ConsoleKey(const struct FKey& Key);
	void EnableCheats();
	void FOV(float NewFOV);
	void K2_ClientPlayForceFeedback(class UForceFeedbackEffect* ForceFeedbackEffect, class FName Tag, bool bLooping, bool bIgnoreTimeDilation, bool bPlayWhilePaused);
	void LocalTravel(const class FString& URL);
	void OnRep_AsyncPhysicsDataComponent();
	void OnServerStartedVisualLogger(bool bIsLogging);
	void Pause();
	void PlayDynamicForceFeedback(float Intensity, float Duration, bool bAffectsLeftLarge, bool bAffectsLeftSmall, bool bAffectsRightLarge, bool bAffectsRightSmall, EDynamicForceFeedbackAction ACTION, const struct FLatentActionInfo& LatentInfo);
	void PlayHapticEffect(class UHapticFeedbackEffect_Base* HapticEffect, EControllerHand Hand, float Scale, bool bLoop);
	void ResetControllerLightColor();
	void RestartLevel();
	void SendToConsole(const class FString& Command);
	void ServerAcknowledgePossession(class APawn* P);
	void ServerBlockPlayer(const struct FUniqueNetIdRepl& PlayerId);
	void ServerCamera(class FName NewMode);
	void ServerChangeName(const class FString& S);
	void ServerCheckClientPossession();
	void ServerCheckClientPossessionReliable();
	void ServerExec(const class FString& Msg);
	void ServerExecRPC(const class FString& Msg);
	void ServerMutePlayer(const struct FUniqueNetIdRepl& PlayerId);
	void ServerNotifyLoadedWorld(class FName WorldPackageName);
	void ServerPause();
	void ServerRecvClientInputFrame(int32 RecvClientInputFrame, const TArray<uint8>& Data);
	void ServerRestartPlayer();
	void ServerSendLatestAsyncPhysicsTimestamp(const struct FAsyncPhysicsTimestamp& Timestamp);
	void ServerSetSpectatorLocation(const struct FVector& NewLoc, const struct FRotator& NewRot);
	void ServerSetSpectatorWaiting(bool bWaiting);
	void ServerShortTimeout();
	void ServerToggleAILogging();
	void ServerUnblockPlayer(const struct FUniqueNetIdRepl& PlayerId);
	void ServerUnmutePlayer(const struct FUniqueNetIdRepl& PlayerId);
	void ServerUpdateCamera(const struct FVector_NetQuantize& CamLoc, int32 CamPitchAndYaw);
	void ServerUpdateLevelVisibility(const struct FUpdateLevelVisibilityLevelInfo& LevelVisibility);
	void ServerUpdateMultipleLevelsVisibility(const TArray<struct FUpdateLevelVisibilityLevelInfo>& LevelVisibilities);
	void ServerVerifyViewTarget();
	void ServerViewNextPlayer();
	void ServerViewPrevPlayer();
	void ServerViewSelf(const struct FViewTargetTransitionParams& TransitionParams);
	void SetAudioListenerAttenuationOverride(class USceneComponent* AttachToComponent, const struct FVector& AttenuationLocationOVerride);
	void SetAudioListenerOverride(class USceneComponent* AttachToComponent, const struct FVector& Location, const struct FRotator& Rotation);
	void SetCinematicMode(bool bInCinematicMode, bool bHidePlayer, bool bAffectsHUD, bool bAffectsMovement, bool bAffectsTurning);
	void SetControllerLightColor(const struct FColor& Color);
	void SetDeprecatedInputPitchScale(float NewValue);
	void SetDeprecatedInputRollScale(float NewValue);
	void SetDeprecatedInputYawScale(float NewValue);
	void SetDisableHaptics(bool bNewDisabled);
	void SetHapticsByValue(const float Frequency, const float Amplitude, EControllerHand Hand);
	void SetMotionControlsEnabled(bool bEnabled);
	void SetMouseCursorWidget(EMouseCursor Cursor, class UUserWidget* CursorWidget);
	void SetMouseLocation(const int32 X, const int32 Y);
	void SetName(const class FString& S);
	void SetViewTargetWithBlend(class AActor* NewViewTarget, float BlendTime, EViewTargetBlendFunction BlendFunc, float BlendExp, bool bLockOutgoing);
	void SetVirtualJoystickVisibility(bool bVisible);
	void StartFire(uint8 FireModeNum);
	void StopHapticEffect(EControllerHand Hand);
	void SwitchLevel(const class FString& URL);
	void TestServerLevelVisibilityChange(const class FName PackageName, const class FName Filename);
	void ToggleSpeaking(bool bInSpeaking);

	bool DeprojectMousePositionToWorld(struct FVector* WorldLocation, struct FVector* WorldDirection) const;
	bool DeprojectScreenPositionToWorld(float ScreenX, float ScreenY, struct FVector* WorldLocation, struct FVector* WorldDirection) const;
	const class UAsyncPhysicsData* GetAsyncPhysicsDataToConsume() const;
	class UAsyncPhysicsData* GetAsyncPhysicsDataToWrite() const;
	float GetDeprecatedInputPitchScale() const;
	float GetDeprecatedInputRollScale() const;
	float GetDeprecatedInputYawScale() const;
	struct FVector GetFocalLocation() const;
	bool GetHitResultUnderCursor(ECollisionChannel TraceChannel, bool bTraceComplex, struct FHitResult* HitResult) const;
	bool GetHitResultUnderCursorByChannel(ETraceTypeQuery TraceChannel, bool bTraceComplex, struct FHitResult* HitResult) const;
	bool GetHitResultUnderCursorForObjects(const TArray<EObjectTypeQuery>& ObjectTypes, bool bTraceComplex, struct FHitResult* HitResult) const;
	bool GetHitResultUnderFinger(ETouchIndex FingerIndex, ECollisionChannel TraceChannel, bool bTraceComplex, struct FHitResult* HitResult) const;
	bool GetHitResultUnderFingerByChannel(ETouchIndex FingerIndex, ETraceTypeQuery TraceChannel, bool bTraceComplex, struct FHitResult* HitResult) const;
	bool GetHitResultUnderFingerForObjects(ETouchIndex FingerIndex, const TArray<EObjectTypeQuery>& ObjectTypes, bool bTraceComplex, struct FHitResult* HitResult) const;
	class AHUD* GetHUD() const;
	float GetInputAnalogKeyState(const struct FKey& Key) const;
	void GetInputAnalogStickState(EControllerAnalogStick WhichStick, float* StickX, float* StickY) const;
	float GetInputKeyTimeDown(const struct FKey& Key) const;
	void GetInputMotionState(struct FVector* Tilt, struct FVector* RotationRate, struct FVector* Gravity, struct FVector* Acceleration) const;
	void GetInputMouseDelta(float* DeltaX, float* DeltaY) const;
	void GetInputTouchState(ETouchIndex FingerIndex, float* LocationX, float* LocationY, bool* bIsCurrentlyPressed) const;
	struct FVector GetInputVectorKeyState(const struct FKey& Key) const;
	bool GetMousePosition(float* LocationX, float* LocationY) const;
	TSubclassOf<class UPlayerInput> GetOverridePlayerInputClass() const;
	struct FPlatformUserId GetPlatformUserId() const;
	class ASpectatorPawn* GetSpectatorPawn() const;
	void GetStreamingSourceLocationAndRotation(struct FVector* OutLocation, struct FRotator* OutRotation) const;
	EStreamingSourcePriority GetStreamingSourcePriority() const;
	void GetStreamingSourceShapes(TArray<struct FStreamingSourceShape>* OutShapes) const;
	void GetViewportSize(int32* SizeX, int32* SizeY) const;
	bool IsInputKeyDown(const struct FKey& Key) const;
	bool IsStreamingSourceEnabled() const;
	bool ProjectWorldLocationToScreen(const struct FVector& WorldLocation, struct FVector2D* ScreenLocation, bool bPlayerViewportRelative) const;
	bool StreamingSourceShouldActivate() const;
	bool StreamingSourceShouldBlockOnSlowStreaming() const;
	bool WasInputKeyJustPressed(const struct FKey& Key) const;
	bool WasInputKeyJustReleased(const struct FKey& Key) const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"PlayerController">();
	}
	static class APlayerController* GetDefaultObj()
	{
		return GetDefaultObjImpl<APlayerController>();
	}
};
static_assert(alignof(APlayerController) == 0x000008, "Wrong alignment on APlayerController");
static_assert(sizeof(APlayerController) == 0x000860, "Wrong size on APlayerController");
static_assert(offsetof(APlayerController, Player) == 0x000340, "Member 'APlayerController::Player' has a wrong offset!");
static_assert(offsetof(APlayerController, AcknowledgedPawn) == 0x000348, "Member 'APlayerController::AcknowledgedPawn' has a wrong offset!");
static_assert(offsetof(APlayerController, MyHUD) == 0x000350, "Member 'APlayerController::MyHUD' has a wrong offset!");
static_assert(offsetof(APlayerController, PlayerCameraManager) == 0x000358, "Member 'APlayerController::PlayerCameraManager' has a wrong offset!");
static_assert(offsetof(APlayerController, PlayerCameraManagerClass) == 0x000360, "Member 'APlayerController::PlayerCameraManagerClass' has a wrong offset!");
static_assert(offsetof(APlayerController, bAutoManageActiveCameraTarget) == 0x000368, "Member 'APlayerController::bAutoManageActiveCameraTarget' has a wrong offset!");
static_assert(offsetof(APlayerController, TargetViewRotation) == 0x000370, "Member 'APlayerController::TargetViewRotation' has a wrong offset!");
static_assert(offsetof(APlayerController, SmoothTargetViewRotationSpeed) == 0x0003A0, "Member 'APlayerController::SmoothTargetViewRotationSpeed' has a wrong offset!");
static_assert(offsetof(APlayerController, HiddenActors) == 0x0003A8, "Member 'APlayerController::HiddenActors' has a wrong offset!");
static_assert(offsetof(APlayerController, HiddenPrimitiveComponents) == 0x0003B8, "Member 'APlayerController::HiddenPrimitiveComponents' has a wrong offset!");
static_assert(offsetof(APlayerController, LastSpectatorStateSynchTime) == 0x0003CC, "Member 'APlayerController::LastSpectatorStateSynchTime' has a wrong offset!");
static_assert(offsetof(APlayerController, LastSpectatorSyncLocation) == 0x0003D0, "Member 'APlayerController::LastSpectatorSyncLocation' has a wrong offset!");
static_assert(offsetof(APlayerController, LastSpectatorSyncRotation) == 0x0003E8, "Member 'APlayerController::LastSpectatorSyncRotation' has a wrong offset!");
static_assert(offsetof(APlayerController, ClientCap) == 0x000400, "Member 'APlayerController::ClientCap' has a wrong offset!");
static_assert(offsetof(APlayerController, CheatManager) == 0x000408, "Member 'APlayerController::CheatManager' has a wrong offset!");
static_assert(offsetof(APlayerController, CheatClass) == 0x000410, "Member 'APlayerController::CheatClass' has a wrong offset!");
static_assert(offsetof(APlayerController, PlayerInput) == 0x000418, "Member 'APlayerController::PlayerInput' has a wrong offset!");
static_assert(offsetof(APlayerController, ActiveForceFeedbackEffects) == 0x000420, "Member 'APlayerController::ActiveForceFeedbackEffects' has a wrong offset!");
static_assert(offsetof(APlayerController, AsyncPhysicsDataClass) == 0x000430, "Member 'APlayerController::AsyncPhysicsDataClass' has a wrong offset!");
static_assert(offsetof(APlayerController, AsyncPhysicsDataComponent_DEPRECARED) == 0x000438, "Member 'APlayerController::AsyncPhysicsDataComponent_DEPRECARED' has a wrong offset!");
static_assert(offsetof(APlayerController, NetPlayerIndex) == 0x0004C4, "Member 'APlayerController::NetPlayerIndex' has a wrong offset!");
static_assert(offsetof(APlayerController, PendingSwapConnection) == 0x000520, "Member 'APlayerController::PendingSwapConnection' has a wrong offset!");
static_assert(offsetof(APlayerController, NetConnection) == 0x000528, "Member 'APlayerController::NetConnection' has a wrong offset!");
static_assert(offsetof(APlayerController, InputYawScale) == 0x000548, "Member 'APlayerController::InputYawScale' has a wrong offset!");
static_assert(offsetof(APlayerController, InputPitchScale) == 0x00054C, "Member 'APlayerController::InputPitchScale' has a wrong offset!");
static_assert(offsetof(APlayerController, InputRollScale) == 0x000550, "Member 'APlayerController::InputRollScale' has a wrong offset!");
static_assert(offsetof(APlayerController, StreamingSourcePriority) == 0x000558, "Member 'APlayerController::StreamingSourcePriority' has a wrong offset!");
static_assert(offsetof(APlayerController, StreamingSourceDebugColor) == 0x00055C, "Member 'APlayerController::StreamingSourceDebugColor' has a wrong offset!");
static_assert(offsetof(APlayerController, StreamingSourceShapes) == 0x000560, "Member 'APlayerController::StreamingSourceShapes' has a wrong offset!");
static_assert(offsetof(APlayerController, ForceFeedbackScale) == 0x000570, "Member 'APlayerController::ForceFeedbackScale' has a wrong offset!");
static_assert(offsetof(APlayerController, ClickEventKeys) == 0x000578, "Member 'APlayerController::ClickEventKeys' has a wrong offset!");
static_assert(offsetof(APlayerController, DefaultMouseCursor) == 0x000588, "Member 'APlayerController::DefaultMouseCursor' has a wrong offset!");
static_assert(offsetof(APlayerController, CurrentMouseCursor) == 0x000589, "Member 'APlayerController::CurrentMouseCursor' has a wrong offset!");
static_assert(offsetof(APlayerController, DefaultClickTraceChannel) == 0x00058A, "Member 'APlayerController::DefaultClickTraceChannel' has a wrong offset!");
static_assert(offsetof(APlayerController, CurrentClickTraceChannel) == 0x00058B, "Member 'APlayerController::CurrentClickTraceChannel' has a wrong offset!");
static_assert(offsetof(APlayerController, HitResultTraceDistance) == 0x00058C, "Member 'APlayerController::HitResultTraceDistance' has a wrong offset!");
static_assert(offsetof(APlayerController, SeamlessTravelCount) == 0x000590, "Member 'APlayerController::SeamlessTravelCount' has a wrong offset!");
static_assert(offsetof(APlayerController, LastCompletedSeamlessTravelCount) == 0x000592, "Member 'APlayerController::LastCompletedSeamlessTravelCount' has a wrong offset!");
static_assert(offsetof(APlayerController, InactiveStateInputComponent) == 0x000618, "Member 'APlayerController::InactiveStateInputComponent' has a wrong offset!");
static_assert(offsetof(APlayerController, CurrentTouchInterface) == 0x000638, "Member 'APlayerController::CurrentTouchInterface' has a wrong offset!");
static_assert(offsetof(APlayerController, OverridePlayerInputClass) == 0x000640, "Member 'APlayerController::OverridePlayerInputClass' has a wrong offset!");
static_assert(offsetof(APlayerController, SpectatorPawn) == 0x0006C0, "Member 'APlayerController::SpectatorPawn' has a wrong offset!");
static_assert(offsetof(APlayerController, bIsLocalPlayerController) == 0x0006CC, "Member 'APlayerController::bIsLocalPlayerController' has a wrong offset!");
static_assert(offsetof(APlayerController, SpawnLocation) == 0x0006D0, "Member 'APlayerController::SpawnLocation' has a wrong offset!");

// Class Engine.StereoLayerShapeQuad
// 0x0000 (0x0028 - 0x0028)
class UStereoLayerShapeQuad final : public UStereoLayerShape
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"StereoLayerShapeQuad">();
	}
	static class UStereoLayerShapeQuad* GetDefaultObj()
	{
		return GetDefaultObjImpl<UStereoLayerShapeQuad>();
	}
};
static_assert(alignof(UStereoLayerShapeQuad) == 0x000008, "Wrong alignment on UStereoLayerShapeQuad");
static_assert(sizeof(UStereoLayerShapeQuad) == 0x000028, "Wrong size on UStereoLayerShapeQuad");

// Class Engine.StereoLayerShapeCylinder
// 0x0010 (0x0038 - 0x0028)
class UStereoLayerShapeCylinder final : public UStereoLayerShape
{
public:
	float                                         Radius;                                            // 0x0028(0x0004)(Edit, BlueprintVisible, ExportObject, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         OverlayArc;                                        // 0x002C(0x0004)(Edit, BlueprintVisible, ExportObject, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         Height;                                            // 0x0030(0x0004)(Edit, BlueprintVisible, ExportObject, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_34[0x4];                                       // 0x0034(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void SetHeight(int32 InHeight);
	void SetOverlayArc(float InOverlayArc);
	void SetRadius(float InRadius);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"StereoLayerShapeCylinder">();
	}
	static class UStereoLayerShapeCylinder* GetDefaultObj()
	{
		return GetDefaultObjImpl<UStereoLayerShapeCylinder>();
	}
};
static_assert(alignof(UStereoLayerShapeCylinder) == 0x000008, "Wrong alignment on UStereoLayerShapeCylinder");
static_assert(sizeof(UStereoLayerShapeCylinder) == 0x000038, "Wrong size on UStereoLayerShapeCylinder");
static_assert(offsetof(UStereoLayerShapeCylinder, Radius) == 0x000028, "Member 'UStereoLayerShapeCylinder::Radius' has a wrong offset!");
static_assert(offsetof(UStereoLayerShapeCylinder, OverlayArc) == 0x00002C, "Member 'UStereoLayerShapeCylinder::OverlayArc' has a wrong offset!");
static_assert(offsetof(UStereoLayerShapeCylinder, Height) == 0x000030, "Member 'UStereoLayerShapeCylinder::Height' has a wrong offset!");

// Class Engine.StereoLayerShapeCubemap
// 0x0000 (0x0028 - 0x0028)
class UStereoLayerShapeCubemap final : public UStereoLayerShape
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"StereoLayerShapeCubemap">();
	}
	static class UStereoLayerShapeCubemap* GetDefaultObj()
	{
		return GetDefaultObjImpl<UStereoLayerShapeCubemap>();
	}
};
static_assert(alignof(UStereoLayerShapeCubemap) == 0x000008, "Wrong alignment on UStereoLayerShapeCubemap");
static_assert(sizeof(UStereoLayerShapeCubemap) == 0x000028, "Wrong size on UStereoLayerShapeCubemap");

// Class Engine.StereoLayerShapeEquirect
// 0x0098 (0x00C0 - 0x0028)
class UStereoLayerShapeEquirect final : public UStereoLayerShape
{
public:
	struct FBox2D                                 LeftUVRect;                                        // 0x0028(0x0028)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
	struct FBox2D                                 RightUVRect;                                       // 0x0050(0x0028)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
	struct FVector2D                              LeftScale;                                         // 0x0078(0x0010)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector2D                              RightScale;                                        // 0x0088(0x0010)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector2D                              LeftBias;                                          // 0x0098(0x0010)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector2D                              RightBias;                                         // 0x00A8(0x0010)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         Radius;                                            // 0x00B8(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_BC[0x4];                                       // 0x00BC(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void SetEquirectProps(const struct FEquirectProps& InScaleBiases);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"StereoLayerShapeEquirect">();
	}
	static class UStereoLayerShapeEquirect* GetDefaultObj()
	{
		return GetDefaultObjImpl<UStereoLayerShapeEquirect>();
	}
};
static_assert(alignof(UStereoLayerShapeEquirect) == 0x000008, "Wrong alignment on UStereoLayerShapeEquirect");
static_assert(sizeof(UStereoLayerShapeEquirect) == 0x0000C0, "Wrong size on UStereoLayerShapeEquirect");
static_assert(offsetof(UStereoLayerShapeEquirect, LeftUVRect) == 0x000028, "Member 'UStereoLayerShapeEquirect::LeftUVRect' has a wrong offset!");
static_assert(offsetof(UStereoLayerShapeEquirect, RightUVRect) == 0x000050, "Member 'UStereoLayerShapeEquirect::RightUVRect' has a wrong offset!");
static_assert(offsetof(UStereoLayerShapeEquirect, LeftScale) == 0x000078, "Member 'UStereoLayerShapeEquirect::LeftScale' has a wrong offset!");
static_assert(offsetof(UStereoLayerShapeEquirect, RightScale) == 0x000088, "Member 'UStereoLayerShapeEquirect::RightScale' has a wrong offset!");
static_assert(offsetof(UStereoLayerShapeEquirect, LeftBias) == 0x000098, "Member 'UStereoLayerShapeEquirect::LeftBias' has a wrong offset!");
static_assert(offsetof(UStereoLayerShapeEquirect, RightBias) == 0x0000A8, "Member 'UStereoLayerShapeEquirect::RightBias' has a wrong offset!");
static_assert(offsetof(UStereoLayerShapeEquirect, Radius) == 0x0000B8, "Member 'UStereoLayerShapeEquirect::Radius' has a wrong offset!");

// Class Engine.CurveFloat
// 0x0088 (0x00B8 - 0x0030)
class UCurveFloat final : public UCurveBase
{
public:
	struct FRichCurve                             FloatCurve;                                        // 0x0030(0x0080)(NativeAccessSpecifierPublic)
	bool                                          bIsEventCurve;                                     // 0x00B0(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_B1[0x7];                                       // 0x00B1(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	float GetFloatValue(float InTime) const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"CurveFloat">();
	}
	static class UCurveFloat* GetDefaultObj()
	{
		return GetDefaultObjImpl<UCurveFloat>();
	}
};
static_assert(alignof(UCurveFloat) == 0x000008, "Wrong alignment on UCurveFloat");
static_assert(sizeof(UCurveFloat) == 0x0000B8, "Wrong size on UCurveFloat");
static_assert(offsetof(UCurveFloat, FloatCurve) == 0x000030, "Member 'UCurveFloat::FloatCurve' has a wrong offset!");
static_assert(offsetof(UCurveFloat, bIsEventCurve) == 0x0000B0, "Member 'UCurveFloat::bIsEventCurve' has a wrong offset!");

// Class Engine.StereoLayerComponent
// 0x0190 (0x0430 - 0x02A0)
class UStereoLayerComponent final : public USceneComponent
{
public:
	uint8                                         bLiveTexture : 1;                                  // 0x02A0(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bSupportsDepth : 1;                                // 0x02A0(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bNoAlphaChannel : 1;                               // 0x02A0(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_2A1[0x7];                                      // 0x02A1(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	class UTexture*                               Texture;                                           // 0x02A8(0x0008)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, NoDestructor, Protected, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	class UTexture*                               LeftTexture;                                       // 0x02B0(0x0008)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, NoDestructor, Protected, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         bQuadPreserveTextureRatio : 1;                     // 0x02B8(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_2B9[0x7];                                      // 0x02B9(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	struct FVector2D                              QuadSize;                                          // 0x02C0(0x0010)(Edit, BlueprintVisible, ExportObject, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	struct FBox2D                                 UVRect;                                            // 0x02D0(0x0028)(Edit, BlueprintVisible, ExportObject, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, NativeAccessSpecifierProtected)
	float                                         CylinderRadius;                                    // 0x02F8(0x0004)(ZeroConstructor, Deprecated, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	float                                         CylinderOverlayArc;                                // 0x02FC(0x0004)(ZeroConstructor, Deprecated, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	int32                                         CylinderHeight;                                    // 0x0300(0x0004)(ZeroConstructor, Deprecated, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_304[0x4];                                      // 0x0304(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	struct FEquirectProps                         EquirectProps;                                     // 0x0308(0x0098)(Deprecated, NoDestructor, Protected, NativeAccessSpecifierProtected)
	EStereoLayerType                              StereoLayerType;                                   // 0x03A0(0x0001)(Edit, BlueprintVisible, ExportObject, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	EStereoLayerShape                             StereoLayerShape;                                  // 0x03A1(0x0001)(ZeroConstructor, Deprecated, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_3A2[0x6];                                      // 0x03A2(0x0006)(Fixing Size After Last Property [ Dumper-7 ])
	class UStereoLayerShape*                      Shape;                                             // 0x03A8(0x0008)(Edit, BlueprintVisible, ExportObject, BlueprintReadOnly, ZeroConstructor, InstancedReference, NoClear, NoDestructor, Protected, PersistentInstance, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	int32                                         Priority;                                          // 0x03B0(0x0004)(Edit, BlueprintVisible, ExportObject, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_3B4[0x7C];                                     // 0x03B4(0x007C)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void MarkTextureForUpdate();
	void SetEquirectProps(const struct FEquirectProps& InEquirectProps);
	void SetLeftTexture(class UTexture* InTexture);
	void SetPriority(int32 InPriority);
	void SetQuadSize(const struct FVector2D& InQuadSize);
	void SetTexture(class UTexture* InTexture);
	void SetUVRect(const struct FBox2D& InUVRect);

	class UTexture* GetLeftTexture() const;
	int32 GetPriority() const;
	struct FVector2D GetQuadSize() const;
	class UTexture* GetTexture() const;
	struct FBox2D GetUVRect() const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"StereoLayerComponent">();
	}
	static class UStereoLayerComponent* GetDefaultObj()
	{
		return GetDefaultObjImpl<UStereoLayerComponent>();
	}
};
static_assert(alignof(UStereoLayerComponent) == 0x000010, "Wrong alignment on UStereoLayerComponent");
static_assert(sizeof(UStereoLayerComponent) == 0x000430, "Wrong size on UStereoLayerComponent");
static_assert(offsetof(UStereoLayerComponent, Texture) == 0x0002A8, "Member 'UStereoLayerComponent::Texture' has a wrong offset!");
static_assert(offsetof(UStereoLayerComponent, LeftTexture) == 0x0002B0, "Member 'UStereoLayerComponent::LeftTexture' has a wrong offset!");
static_assert(offsetof(UStereoLayerComponent, QuadSize) == 0x0002C0, "Member 'UStereoLayerComponent::QuadSize' has a wrong offset!");
static_assert(offsetof(UStereoLayerComponent, UVRect) == 0x0002D0, "Member 'UStereoLayerComponent::UVRect' has a wrong offset!");
static_assert(offsetof(UStereoLayerComponent, CylinderRadius) == 0x0002F8, "Member 'UStereoLayerComponent::CylinderRadius' has a wrong offset!");
static_assert(offsetof(UStereoLayerComponent, CylinderOverlayArc) == 0x0002FC, "Member 'UStereoLayerComponent::CylinderOverlayArc' has a wrong offset!");
static_assert(offsetof(UStereoLayerComponent, CylinderHeight) == 0x000300, "Member 'UStereoLayerComponent::CylinderHeight' has a wrong offset!");
static_assert(offsetof(UStereoLayerComponent, EquirectProps) == 0x000308, "Member 'UStereoLayerComponent::EquirectProps' has a wrong offset!");
static_assert(offsetof(UStereoLayerComponent, StereoLayerType) == 0x0003A0, "Member 'UStereoLayerComponent::StereoLayerType' has a wrong offset!");
static_assert(offsetof(UStereoLayerComponent, StereoLayerShape) == 0x0003A1, "Member 'UStereoLayerComponent::StereoLayerShape' has a wrong offset!");
static_assert(offsetof(UStereoLayerComponent, Shape) == 0x0003A8, "Member 'UStereoLayerComponent::Shape' has a wrong offset!");
static_assert(offsetof(UStereoLayerComponent, Priority) == 0x0003B0, "Member 'UStereoLayerComponent::Priority' has a wrong offset!");

// Class Engine.SubUVAnimation
// 0x0040 (0x0068 - 0x0028)
class USubUVAnimation final : public UObject
{
public:
	class UTexture2D*                             SubUVTexture;                                      // 0x0028(0x0008)(Edit, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         SubImages_Horizontal;                              // 0x0030(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         SubImages_Vertical;                                // 0x0034(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	ESubUVBoundingVertexCount                     BoundingMode;                                      // 0x0038(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EOpacitySourceMode                            OpacitySourceMode;                                 // 0x0039(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_3A[0x2];                                       // 0x003A(0x0002)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         AlphaThreshold;                                    // 0x003C(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_40[0x28];                                      // 0x0040(0x0028)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"SubUVAnimation">();
	}
	static class USubUVAnimation* GetDefaultObj()
	{
		return GetDefaultObjImpl<USubUVAnimation>();
	}
};
static_assert(alignof(USubUVAnimation) == 0x000008, "Wrong alignment on USubUVAnimation");
static_assert(sizeof(USubUVAnimation) == 0x000068, "Wrong size on USubUVAnimation");
static_assert(offsetof(USubUVAnimation, SubUVTexture) == 0x000028, "Member 'USubUVAnimation::SubUVTexture' has a wrong offset!");
static_assert(offsetof(USubUVAnimation, SubImages_Horizontal) == 0x000030, "Member 'USubUVAnimation::SubImages_Horizontal' has a wrong offset!");
static_assert(offsetof(USubUVAnimation, SubImages_Vertical) == 0x000034, "Member 'USubUVAnimation::SubImages_Vertical' has a wrong offset!");
static_assert(offsetof(USubUVAnimation, BoundingMode) == 0x000038, "Member 'USubUVAnimation::BoundingMode' has a wrong offset!");
static_assert(offsetof(USubUVAnimation, OpacitySourceMode) == 0x000039, "Member 'USubUVAnimation::OpacitySourceMode' has a wrong offset!");
static_assert(offsetof(USubUVAnimation, AlphaThreshold) == 0x00003C, "Member 'USubUVAnimation::AlphaThreshold' has a wrong offset!");

// Class Engine.WorldPartitionRuntimeCellData
// 0x0060 (0x0088 - 0x0028)
class UWorldPartitionRuntimeCellData : public UObject
{
public:
	uint8                                         Pad_28[0x20];                                      // 0x0028(0x0020)(Fixing Size After Last Property [ Dumper-7 ])
	struct FBox                                   ContentBounds;                                     // 0x0048(0x0038)(ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
	uint8                                         Pad_80[0x8];                                       // 0x0080(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"WorldPartitionRuntimeCellData">();
	}
	static class UWorldPartitionRuntimeCellData* GetDefaultObj()
	{
		return GetDefaultObjImpl<UWorldPartitionRuntimeCellData>();
	}
};
static_assert(alignof(UWorldPartitionRuntimeCellData) == 0x000008, "Wrong alignment on UWorldPartitionRuntimeCellData");
static_assert(sizeof(UWorldPartitionRuntimeCellData) == 0x000088, "Wrong size on UWorldPartitionRuntimeCellData");
static_assert(offsetof(UWorldPartitionRuntimeCellData, ContentBounds) == 0x000048, "Member 'UWorldPartitionRuntimeCellData::ContentBounds' has a wrong offset!");

// Class Engine.WorldPartitionRuntimeCellDataSpatialHash
// 0x0068 (0x00F0 - 0x0088)
class UWorldPartitionRuntimeCellDataSpatialHash final : public UWorldPartitionRuntimeCellData
{
public:
	struct FVector                                position;                                          // 0x0088(0x0018)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         Extent;                                            // 0x00A0(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         Level;                                             // 0x00A4(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FName                                   GridName;                                          // 0x00A8(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_B0[0x40];                                      // 0x00B0(0x0040)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"WorldPartitionRuntimeCellDataSpatialHash">();
	}
	static class UWorldPartitionRuntimeCellDataSpatialHash* GetDefaultObj()
	{
		return GetDefaultObjImpl<UWorldPartitionRuntimeCellDataSpatialHash>();
	}
};
static_assert(alignof(UWorldPartitionRuntimeCellDataSpatialHash) == 0x000008, "Wrong alignment on UWorldPartitionRuntimeCellDataSpatialHash");
static_assert(sizeof(UWorldPartitionRuntimeCellDataSpatialHash) == 0x0000F0, "Wrong size on UWorldPartitionRuntimeCellDataSpatialHash");
static_assert(offsetof(UWorldPartitionRuntimeCellDataSpatialHash, position) == 0x000088, "Member 'UWorldPartitionRuntimeCellDataSpatialHash::position' has a wrong offset!");
static_assert(offsetof(UWorldPartitionRuntimeCellDataSpatialHash, Extent) == 0x0000A0, "Member 'UWorldPartitionRuntimeCellDataSpatialHash::Extent' has a wrong offset!");
static_assert(offsetof(UWorldPartitionRuntimeCellDataSpatialHash, Level) == 0x0000A4, "Member 'UWorldPartitionRuntimeCellDataSpatialHash::Level' has a wrong offset!");
static_assert(offsetof(UWorldPartitionRuntimeCellDataSpatialHash, GridName) == 0x0000A8, "Member 'UWorldPartitionRuntimeCellDataSpatialHash::GridName' has a wrong offset!");

// Class Engine.TextPropertyTestObject
// 0x0048 (0x0070 - 0x0028)
class UTextPropertyTestObject final : public UObject
{
public:
	class FText                                   DefaultedText;                                     // 0x0028(0x0018)(NativeAccessSpecifierPublic)
	class FText                                   UndefaultedText;                                   // 0x0040(0x0018)(NativeAccessSpecifierPublic)
	class FText                                   TransientText;                                     // 0x0058(0x0018)(NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"TextPropertyTestObject">();
	}
	static class UTextPropertyTestObject* GetDefaultObj()
	{
		return GetDefaultObjImpl<UTextPropertyTestObject>();
	}
};
static_assert(alignof(UTextPropertyTestObject) == 0x000008, "Wrong alignment on UTextPropertyTestObject");
static_assert(sizeof(UTextPropertyTestObject) == 0x000070, "Wrong size on UTextPropertyTestObject");
static_assert(offsetof(UTextPropertyTestObject, DefaultedText) == 0x000028, "Member 'UTextPropertyTestObject::DefaultedText' has a wrong offset!");
static_assert(offsetof(UTextPropertyTestObject, UndefaultedText) == 0x000040, "Member 'UTextPropertyTestObject::UndefaultedText' has a wrong offset!");
static_assert(offsetof(UTextPropertyTestObject, TransientText) == 0x000058, "Member 'UTextPropertyTestObject::TransientText' has a wrong offset!");

// Class Engine.TextRenderActor
// 0x0008 (0x02A8 - 0x02A0)
class ATextRenderActor final : public AActor
{
public:
	class UTextRenderComponent*                   TextRender;                                        // 0x02A0(0x0008)(Edit, BlueprintVisible, ExportObject, BlueprintReadOnly, ZeroConstructor, EditConst, InstancedReference, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"TextRenderActor">();
	}
	static class ATextRenderActor* GetDefaultObj()
	{
		return GetDefaultObjImpl<ATextRenderActor>();
	}
};
static_assert(alignof(ATextRenderActor) == 0x000008, "Wrong alignment on ATextRenderActor");
static_assert(sizeof(ATextRenderActor) == 0x0002A8, "Wrong size on ATextRenderActor");
static_assert(offsetof(ATextRenderActor, TextRender) == 0x0002A0, "Member 'ATextRenderActor::TextRender' has a wrong offset!");

// Class Engine.DamageType
// 0x0018 (0x0040 - 0x0028)
class UDamageType : public UObject
{
public:
	uint8                                         bCausedByWorld : 1;                                // 0x0028(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bScaleMomentumByMass : 1;                          // 0x0028(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bRadialDamageVelChange : 1;                        // 0x0028(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_29[0x3];                                       // 0x0029(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         DamageImpulse;                                     // 0x002C(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         DestructibleImpulse;                               // 0x0030(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         DestructibleDamageSpreadScale;                     // 0x0034(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         DamageFalloff;                                     // 0x0038(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_3C[0x4];                                       // 0x003C(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"DamageType">();
	}
	static class UDamageType* GetDefaultObj()
	{
		return GetDefaultObjImpl<UDamageType>();
	}
};
static_assert(alignof(UDamageType) == 0x000008, "Wrong alignment on UDamageType");
static_assert(sizeof(UDamageType) == 0x000040, "Wrong size on UDamageType");
static_assert(offsetof(UDamageType, DamageImpulse) == 0x00002C, "Member 'UDamageType::DamageImpulse' has a wrong offset!");
static_assert(offsetof(UDamageType, DestructibleImpulse) == 0x000030, "Member 'UDamageType::DestructibleImpulse' has a wrong offset!");
static_assert(offsetof(UDamageType, DestructibleDamageSpreadScale) == 0x000034, "Member 'UDamageType::DestructibleDamageSpreadScale' has a wrong offset!");
static_assert(offsetof(UDamageType, DamageFalloff) == 0x000038, "Member 'UDamageType::DamageFalloff' has a wrong offset!");

// Class Engine.WorldPartitionStreamingPolicy
// 0x0260 (0x0288 - 0x0028)
class UWorldPartitionStreamingPolicy : public UObject
{
public:
	uint8                                         Pad_28[0x260];                                     // 0x0028(0x0260)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"WorldPartitionStreamingPolicy">();
	}
	static class UWorldPartitionStreamingPolicy* GetDefaultObj()
	{
		return GetDefaultObjImpl<UWorldPartitionStreamingPolicy>();
	}
};
static_assert(alignof(UWorldPartitionStreamingPolicy) == 0x000008, "Wrong alignment on UWorldPartitionStreamingPolicy");
static_assert(sizeof(UWorldPartitionStreamingPolicy) == 0x000288, "Wrong size on UWorldPartitionStreamingPolicy");

// Class Engine.TextRenderComponent
// 0x0050 (0x05C0 - 0x0570)
class UTextRenderComponent final : public UPrimitiveComponent
{
public:
	class FText                                   Text;                                              // 0x0570(0x0018)(Edit, BlueprintVisible, BlueprintReadOnly, NativeAccessSpecifierPublic)
	class UMaterialInterface*                     TextMaterial;                                      // 0x0588(0x0008)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UFont*                                  Font;                                              // 0x0590(0x0008)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EHorizTextAligment                            HorizontalAlignment;                               // 0x0598(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EVerticalTextAligment                         VerticalAlignment;                                 // 0x0599(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_59A[0x2];                                      // 0x059A(0x0002)(Fixing Size After Last Property [ Dumper-7 ])
	struct FColor                                 TextRenderColor;                                   // 0x059C(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         XScale;                                            // 0x05A0(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         YScale;                                            // 0x05A4(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         WorldSize;                                         // 0x05A8(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         InvDefaultSize;                                    // 0x05AC(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         HorizSpacingAdjust;                                // 0x05B0(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         VertSpacingAdjust;                                 // 0x05B4(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bAlwaysRenderAsText : 1;                           // 0x05B8(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_5B9[0x7];                                      // 0x05B9(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void K2_SetText(const class FText& Value);
	void SetFont(class UFont* Value);
	void SetHorizontalAlignment(EHorizTextAligment Value);
	void SetHorizSpacingAdjust(float Value);
	void SetText(const class FText& Value);
	void SetTextMaterial(class UMaterialInterface* Material);
	void SetTextRenderColor(const struct FColor& Value);
	void SetVerticalAlignment(EVerticalTextAligment Value);
	void SetVertSpacingAdjust(float Value);
	void SetWorldSize(float Value);
	void SetXScale(float Value);
	void SetYScale(float Value);

	struct FVector GetTextLocalSize() const;
	struct FVector GetTextWorldSize() const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"TextRenderComponent">();
	}
	static class UTextRenderComponent* GetDefaultObj()
	{
		return GetDefaultObjImpl<UTextRenderComponent>();
	}
};
static_assert(alignof(UTextRenderComponent) == 0x000010, "Wrong alignment on UTextRenderComponent");
static_assert(sizeof(UTextRenderComponent) == 0x0005C0, "Wrong size on UTextRenderComponent");
static_assert(offsetof(UTextRenderComponent, Text) == 0x000570, "Member 'UTextRenderComponent::Text' has a wrong offset!");
static_assert(offsetof(UTextRenderComponent, TextMaterial) == 0x000588, "Member 'UTextRenderComponent::TextMaterial' has a wrong offset!");
static_assert(offsetof(UTextRenderComponent, Font) == 0x000590, "Member 'UTextRenderComponent::Font' has a wrong offset!");
static_assert(offsetof(UTextRenderComponent, HorizontalAlignment) == 0x000598, "Member 'UTextRenderComponent::HorizontalAlignment' has a wrong offset!");
static_assert(offsetof(UTextRenderComponent, VerticalAlignment) == 0x000599, "Member 'UTextRenderComponent::VerticalAlignment' has a wrong offset!");
static_assert(offsetof(UTextRenderComponent, TextRenderColor) == 0x00059C, "Member 'UTextRenderComponent::TextRenderColor' has a wrong offset!");
static_assert(offsetof(UTextRenderComponent, XScale) == 0x0005A0, "Member 'UTextRenderComponent::XScale' has a wrong offset!");
static_assert(offsetof(UTextRenderComponent, YScale) == 0x0005A4, "Member 'UTextRenderComponent::YScale' has a wrong offset!");
static_assert(offsetof(UTextRenderComponent, WorldSize) == 0x0005A8, "Member 'UTextRenderComponent::WorldSize' has a wrong offset!");
static_assert(offsetof(UTextRenderComponent, InvDefaultSize) == 0x0005AC, "Member 'UTextRenderComponent::InvDefaultSize' has a wrong offset!");
static_assert(offsetof(UTextRenderComponent, HorizSpacingAdjust) == 0x0005B0, "Member 'UTextRenderComponent::HorizSpacingAdjust' has a wrong offset!");
static_assert(offsetof(UTextRenderComponent, VertSpacingAdjust) == 0x0005B4, "Member 'UTextRenderComponent::VertSpacingAdjust' has a wrong offset!");

// Class Engine.TextureEncodingProjectSettings
// 0x0018 (0x0050 - 0x0038)
class UTextureEncodingProjectSettings final : public UDeveloperSettings
{
public:
	uint8                                         bSharedLinearTextureEncoding : 1;                  // 0x0038(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bFinalUsesRDO : 1;                                 // 0x0038(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_39[0x3];                                       // 0x0039(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	int8                                          FinalRDOLambda;                                    // 0x003C(0x0001)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	ETextureEncodeEffort                          FinalEffortLevel;                                  // 0x003D(0x0001)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	ETextureUniversalTiling                       FinalUniversalTiling;                              // 0x003E(0x0001)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_3F[0x1];                                       // 0x003F(0x0001)(Fixing Size After Last Property [ Dumper-7 ])
	uint8                                         bFastUsesRDO : 1;                                  // 0x0040(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_41[0x3];                                       // 0x0041(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	int8                                          FastRDOLambda;                                     // 0x0044(0x0001)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	ETextureEncodeEffort                          FastEffortLevel;                                   // 0x0045(0x0001)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	ETextureUniversalTiling                       FastUniversalTiling;                               // 0x0046(0x0001)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	ETextureEncodeSpeed                           CookUsesSpeed;                                     // 0x0047(0x0001)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	ETextureEncodeSpeed                           EditorUsesSpeed;                                   // 0x0048(0x0001)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_49[0x7];                                       // 0x0049(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"TextureEncodingProjectSettings">();
	}
	static class UTextureEncodingProjectSettings* GetDefaultObj()
	{
		return GetDefaultObjImpl<UTextureEncodingProjectSettings>();
	}
};
static_assert(alignof(UTextureEncodingProjectSettings) == 0x000008, "Wrong alignment on UTextureEncodingProjectSettings");
static_assert(sizeof(UTextureEncodingProjectSettings) == 0x000050, "Wrong size on UTextureEncodingProjectSettings");
static_assert(offsetof(UTextureEncodingProjectSettings, FinalRDOLambda) == 0x00003C, "Member 'UTextureEncodingProjectSettings::FinalRDOLambda' has a wrong offset!");
static_assert(offsetof(UTextureEncodingProjectSettings, FinalEffortLevel) == 0x00003D, "Member 'UTextureEncodingProjectSettings::FinalEffortLevel' has a wrong offset!");
static_assert(offsetof(UTextureEncodingProjectSettings, FinalUniversalTiling) == 0x00003E, "Member 'UTextureEncodingProjectSettings::FinalUniversalTiling' has a wrong offset!");
static_assert(offsetof(UTextureEncodingProjectSettings, FastRDOLambda) == 0x000044, "Member 'UTextureEncodingProjectSettings::FastRDOLambda' has a wrong offset!");
static_assert(offsetof(UTextureEncodingProjectSettings, FastEffortLevel) == 0x000045, "Member 'UTextureEncodingProjectSettings::FastEffortLevel' has a wrong offset!");
static_assert(offsetof(UTextureEncodingProjectSettings, FastUniversalTiling) == 0x000046, "Member 'UTextureEncodingProjectSettings::FastUniversalTiling' has a wrong offset!");
static_assert(offsetof(UTextureEncodingProjectSettings, CookUsesSpeed) == 0x000047, "Member 'UTextureEncodingProjectSettings::CookUsesSpeed' has a wrong offset!");
static_assert(offsetof(UTextureEncodingProjectSettings, EditorUsesSpeed) == 0x000048, "Member 'UTextureEncodingProjectSettings::EditorUsesSpeed' has a wrong offset!");

// Class Engine.TextureEncodingUserSettings
// 0x0008 (0x0040 - 0x0038)
class UTextureEncodingUserSettings final : public UDeveloperSettings
{
public:
	ETextureEncodeSpeedOverride                   ForceEncodeSpeed;                                  // 0x0038(0x0001)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_39[0x7];                                       // 0x0039(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"TextureEncodingUserSettings">();
	}
	static class UTextureEncodingUserSettings* GetDefaultObj()
	{
		return GetDefaultObjImpl<UTextureEncodingUserSettings>();
	}
};
static_assert(alignof(UTextureEncodingUserSettings) == 0x000008, "Wrong alignment on UTextureEncodingUserSettings");
static_assert(sizeof(UTextureEncodingUserSettings) == 0x000040, "Wrong size on UTextureEncodingUserSettings");
static_assert(offsetof(UTextureEncodingUserSettings, ForceEncodeSpeed) == 0x000038, "Member 'UTextureEncodingUserSettings::ForceEncodeSpeed' has a wrong offset!");

// Class Engine.TimelineComponent
// 0x00A0 (0x0148 - 0x00A8)
class UTimelineComponent final : public UActorComponent
{
public:
	struct FTimeline                              TheTimeline;                                       // 0x00A8(0x0098)(Net, RepNotify, ContainsInstancedReference, NativeAccessSpecifierPrivate)
	uint8                                         bIgnoreTimeDilation : 1;                           // 0x0140(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate))
	uint8                                         Pad_141[0x7];                                      // 0x0141(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void AddEvent(float Time, TDelegate<void()> EventFunc);
	void AddInterpFloat(class UCurveFloat* FloatCurve, TDelegate<void(float Output)> InterpFunc, class FName PropertyName, class FName TrackName);
	void AddInterpLinearColor(class UCurveLinearColor* LinearColorCurve, TDelegate<void(const struct FLinearColor& Output)> InterpFunc, class FName PropertyName, class FName TrackName);
	void AddInterpVector(class UCurveVector* VectorCurve, TDelegate<void(const struct FVector& Output)> InterpFunc, class FName PropertyName, class FName TrackName);
	void OnRep_Timeline(struct FTimeline* OldTimeline);
	void Play();
	void PlayFromStart();
	void Reverse();
	void ReverseFromEnd();
	void SetFloatCurve(class UCurveFloat* NewFloatCurve, class FName FloatTrackName);
	void SetIgnoreTimeDilation(bool bNewIgnoreTimeDilation);
	void SetLinearColorCurve(class UCurveLinearColor* NewLinearColorCurve, class FName LinearColorTrackName);
	void SetLooping(bool bNewLooping);
	void SetNewTime(float NewTime);
	void SetPlaybackPosition(float NewPosition, bool bFireEvents, bool bFireUpdate);
	void SetPlayRate(float NewRate);
	void SetTimelineFinishedFunc(TDelegate<void()> NewTimelineFinishedFunc);
	void SetTimelineLength(float NewLength);
	void SetTimelineLengthMode(ETimelineLengthMode NewLengthMode);
	void SetTimelinePostUpdateFunc(TDelegate<void()> NewTimelinePostUpdateFunc);
	void SetVectorCurve(class UCurveVector* NewVectorCurve, class FName VectorTrackName);
	void Stop();

	bool GetIgnoreTimeDilation() const;
	float GetPlaybackPosition() const;
	float GetPlayRate() const;
	float GetScaledTimelineLength() const;
	float GetTimelineLength() const;
	bool IsLooping() const;
	bool IsPlaying() const;
	bool IsReversing() const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"TimelineComponent">();
	}
	static class UTimelineComponent* GetDefaultObj()
	{
		return GetDefaultObjImpl<UTimelineComponent>();
	}
};
static_assert(alignof(UTimelineComponent) == 0x000008, "Wrong alignment on UTimelineComponent");
static_assert(sizeof(UTimelineComponent) == 0x000148, "Wrong size on UTimelineComponent");
static_assert(offsetof(UTimelineComponent, TheTimeline) == 0x0000A8, "Member 'UTimelineComponent::TheTimeline' has a wrong offset!");

// Class Engine.DataTableFunctionLibrary
// 0x0000 (0x0028 - 0x0028)
class UDataTableFunctionLibrary final : public UBlueprintFunctionLibrary
{
public:
	static bool DoesDataTableRowExist(class UDataTable* Table, class FName RowName);
	static void EvaluateCurveTableRow(class UCurveTable* CurveTable, class FName RowName, float InXY, EEvaluateCurveTableResult* OutResult, float* OutXY, const class FString& ContextString);
	static TArray<class FString> GetDataTableColumnAsString(const class UDataTable* DataTable, class FName PropertyName);
	static bool GetDataTableRowFromName(class UDataTable* Table, class FName RowName, struct FTableRowBase* OutRow);
	static void GetDataTableRowNames(class UDataTable* Table, TArray<class FName>* OutRowNames);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"DataTableFunctionLibrary">();
	}
	static class UDataTableFunctionLibrary* GetDefaultObj()
	{
		return GetDefaultObjImpl<UDataTableFunctionLibrary>();
	}
};
static_assert(alignof(UDataTableFunctionLibrary) == 0x000008, "Wrong alignment on UDataTableFunctionLibrary");
static_assert(sizeof(UDataTableFunctionLibrary) == 0x000028, "Wrong size on UDataTableFunctionLibrary");

// Class Engine.TriggerBase
// 0x0008 (0x02A8 - 0x02A0)
class ATriggerBase : public AActor
{
public:
	class UShapeComponent*                        CollisionComponent;                                // 0x02A0(0x0008)(Edit, BlueprintVisible, ExportObject, BlueprintReadOnly, ZeroConstructor, EditConst, InstancedReference, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"TriggerBase">();
	}
	static class ATriggerBase* GetDefaultObj()
	{
		return GetDefaultObjImpl<ATriggerBase>();
	}
};
static_assert(alignof(ATriggerBase) == 0x000008, "Wrong alignment on ATriggerBase");
static_assert(sizeof(ATriggerBase) == 0x0002A8, "Wrong size on ATriggerBase");
static_assert(offsetof(ATriggerBase, CollisionComponent) == 0x0002A0, "Member 'ATriggerBase::CollisionComponent' has a wrong offset!");

// Class Engine.TriggerBox
// 0x0000 (0x02A8 - 0x02A8)
class ATriggerBox final : public ATriggerBase
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"TriggerBox">();
	}
	static class ATriggerBox* GetDefaultObj()
	{
		return GetDefaultObjImpl<ATriggerBox>();
	}
};
static_assert(alignof(ATriggerBox) == 0x000008, "Wrong alignment on ATriggerBox");
static_assert(sizeof(ATriggerBox) == 0x0002A8, "Wrong size on ATriggerBox");

// Class Engine.TriggerCapsule
// 0x0000 (0x02A8 - 0x02A8)
class ATriggerCapsule final : public ATriggerBase
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"TriggerCapsule">();
	}
	static class ATriggerCapsule* GetDefaultObj()
	{
		return GetDefaultObjImpl<ATriggerCapsule>();
	}
};
static_assert(alignof(ATriggerCapsule) == 0x000008, "Wrong alignment on ATriggerCapsule");
static_assert(sizeof(ATriggerCapsule) == 0x0002A8, "Wrong size on ATriggerCapsule");

// Class Engine.TriggerSphere
// 0x0000 (0x02A8 - 0x02A8)
class ATriggerSphere final : public ATriggerBase
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"TriggerSphere">();
	}
	static class ATriggerSphere* GetDefaultObj()
	{
		return GetDefaultObjImpl<ATriggerSphere>();
	}
};
static_assert(alignof(ATriggerSphere) == 0x000008, "Wrong alignment on ATriggerSphere");
static_assert(sizeof(ATriggerSphere) == 0x0002A8, "Wrong size on ATriggerSphere");

// Class Engine.DebugDrawService
// 0x0000 (0x0028 - 0x0028)
class UDebugDrawService final : public UBlueprintFunctionLibrary
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"DebugDrawService">();
	}
	static class UDebugDrawService* GetDefaultObj()
	{
		return GetDefaultObjImpl<UDebugDrawService>();
	}
};
static_assert(alignof(UDebugDrawService) == 0x000008, "Wrong alignment on UDebugDrawService");
static_assert(sizeof(UDebugDrawService) == 0x000028, "Wrong size on UDebugDrawService");

// Class Engine.TwitterIntegrationBase
// 0x0000 (0x0038 - 0x0038)
class UTwitterIntegrationBase final : public UPlatformInterfaceBase
{
public:
	bool AuthorizeAccounts();
	bool CanShowTweetUI();
	class FString GetAccountName(int32 AccountIndex);
	int32 GetNumAccounts();
	void Init();
	bool ShowTweetUI(const class FString& InitialMessage, const class FString& URL, const class FString& Picture);
	bool TwitterRequest(const class FString& URL, const TArray<class FString>& ParamKeysAndValues, ETwitterRequestMethod RequestMethod, int32 AccountIndex);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"TwitterIntegrationBase">();
	}
	static class UTwitterIntegrationBase* GetDefaultObj()
	{
		return GetDefaultObjImpl<UTwitterIntegrationBase>();
	}
};
static_assert(alignof(UTwitterIntegrationBase) == 0x000008, "Wrong alignment on UTwitterIntegrationBase");
static_assert(sizeof(UTwitterIntegrationBase) == 0x000038, "Wrong size on UTwitterIntegrationBase");

// Class Engine.UserDefinedStruct
// 0x0048 (0x0108 - 0x00C0)
class UUserDefinedStruct : public UScriptStruct
{
public:
	EUserDefinedStructureStatus                   Status;                                            // 0x00C0(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_C1[0x3];                                       // 0x00C1(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	struct FGuid                                  Guid;                                              // 0x00C4(0x0010)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_D4[0x34];                                      // 0x00D4(0x0034)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"UserDefinedStruct">();
	}
	static class UUserDefinedStruct* GetDefaultObj()
	{
		return GetDefaultObjImpl<UUserDefinedStruct>();
	}
};
static_assert(alignof(UUserDefinedStruct) == 0x000008, "Wrong alignment on UUserDefinedStruct");
static_assert(sizeof(UUserDefinedStruct) == 0x000108, "Wrong size on UUserDefinedStruct");
static_assert(offsetof(UUserDefinedStruct, Status) == 0x0000C0, "Member 'UUserDefinedStruct::Status' has a wrong offset!");
static_assert(offsetof(UUserDefinedStruct, Guid) == 0x0000C4, "Member 'UUserDefinedStruct::Guid' has a wrong offset!");

// Class Engine.VariableFrameStrippingSettings
// 0x0008 (0x0030 - 0x0028)
class UVariableFrameStrippingSettings final : public UObject
{
public:
	struct FPerPlatformBool                       UseVariableFrameStripping;                         // 0x0028(0x0001)(Edit, NoDestructor, NativeAccessSpecifierPublic)
	uint8                                         Pad_29[0x3];                                       // 0x0029(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	struct FPerPlatformInt                        FrameStrippingRate;                                // 0x002C(0x0004)(Edit, NoDestructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"VariableFrameStrippingSettings">();
	}
	static class UVariableFrameStrippingSettings* GetDefaultObj()
	{
		return GetDefaultObjImpl<UVariableFrameStrippingSettings>();
	}
};
static_assert(alignof(UVariableFrameStrippingSettings) == 0x000008, "Wrong alignment on UVariableFrameStrippingSettings");
static_assert(sizeof(UVariableFrameStrippingSettings) == 0x000030, "Wrong size on UVariableFrameStrippingSettings");
static_assert(offsetof(UVariableFrameStrippingSettings, UseVariableFrameStripping) == 0x000028, "Member 'UVariableFrameStrippingSettings::UseVariableFrameStripping' has a wrong offset!");
static_assert(offsetof(UVariableFrameStrippingSettings, FrameStrippingRate) == 0x00002C, "Member 'UVariableFrameStrippingSettings::FrameStrippingRate' has a wrong offset!");

// Class Engine.VectorField
// 0x0040 (0x0068 - 0x0028)
class UVectorField : public UObject
{
public:
	struct FBox                                   Bounds;                                            // 0x0028(0x0038)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
	float                                         Intensity;                                         // 0x0060(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_64[0x4];                                       // 0x0064(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"VectorField">();
	}
	static class UVectorField* GetDefaultObj()
	{
		return GetDefaultObjImpl<UVectorField>();
	}
};
static_assert(alignof(UVectorField) == 0x000008, "Wrong alignment on UVectorField");
static_assert(sizeof(UVectorField) == 0x000068, "Wrong size on UVectorField");
static_assert(offsetof(UVectorField, Bounds) == 0x000028, "Member 'UVectorField::Bounds' has a wrong offset!");
static_assert(offsetof(UVectorField, Intensity) == 0x000060, "Member 'UVectorField::Intensity' has a wrong offset!");

// Class Engine.VectorFieldAnimated
// 0x0040 (0x00A8 - 0x0068)
class UVectorFieldAnimated final : public UVectorField
{
public:
	class UTexture2D*                             Texture;                                           // 0x0068(0x0008)(Edit, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EVectorFieldConstructionOp                    ConstructionOp;                                    // 0x0070(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_71[0x3];                                       // 0x0071(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	int32                                         VolumeSizeX;                                       // 0x0074(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         VolumeSizeY;                                       // 0x0078(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         VolumeSizeZ;                                       // 0x007C(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         SubImagesX;                                        // 0x0080(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         SubImagesY;                                        // 0x0084(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         FrameCount;                                        // 0x0088(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         FramesPerSecond;                                   // 0x008C(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bLoop : 1;                                         // 0x0090(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_91[0x7];                                       // 0x0091(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	class UVectorFieldStatic*                     NoiseField;                                        // 0x0098(0x0008)(Edit, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         NoiseScale;                                        // 0x00A0(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         NoiseMax;                                          // 0x00A4(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"VectorFieldAnimated">();
	}
	static class UVectorFieldAnimated* GetDefaultObj()
	{
		return GetDefaultObjImpl<UVectorFieldAnimated>();
	}
};
static_assert(alignof(UVectorFieldAnimated) == 0x000008, "Wrong alignment on UVectorFieldAnimated");
static_assert(sizeof(UVectorFieldAnimated) == 0x0000A8, "Wrong size on UVectorFieldAnimated");
static_assert(offsetof(UVectorFieldAnimated, Texture) == 0x000068, "Member 'UVectorFieldAnimated::Texture' has a wrong offset!");
static_assert(offsetof(UVectorFieldAnimated, ConstructionOp) == 0x000070, "Member 'UVectorFieldAnimated::ConstructionOp' has a wrong offset!");
static_assert(offsetof(UVectorFieldAnimated, VolumeSizeX) == 0x000074, "Member 'UVectorFieldAnimated::VolumeSizeX' has a wrong offset!");
static_assert(offsetof(UVectorFieldAnimated, VolumeSizeY) == 0x000078, "Member 'UVectorFieldAnimated::VolumeSizeY' has a wrong offset!");
static_assert(offsetof(UVectorFieldAnimated, VolumeSizeZ) == 0x00007C, "Member 'UVectorFieldAnimated::VolumeSizeZ' has a wrong offset!");
static_assert(offsetof(UVectorFieldAnimated, SubImagesX) == 0x000080, "Member 'UVectorFieldAnimated::SubImagesX' has a wrong offset!");
static_assert(offsetof(UVectorFieldAnimated, SubImagesY) == 0x000084, "Member 'UVectorFieldAnimated::SubImagesY' has a wrong offset!");
static_assert(offsetof(UVectorFieldAnimated, FrameCount) == 0x000088, "Member 'UVectorFieldAnimated::FrameCount' has a wrong offset!");
static_assert(offsetof(UVectorFieldAnimated, FramesPerSecond) == 0x00008C, "Member 'UVectorFieldAnimated::FramesPerSecond' has a wrong offset!");
static_assert(offsetof(UVectorFieldAnimated, NoiseField) == 0x000098, "Member 'UVectorFieldAnimated::NoiseField' has a wrong offset!");
static_assert(offsetof(UVectorFieldAnimated, NoiseScale) == 0x0000A0, "Member 'UVectorFieldAnimated::NoiseScale' has a wrong offset!");
static_assert(offsetof(UVectorFieldAnimated, NoiseMax) == 0x0000A4, "Member 'UVectorFieldAnimated::NoiseMax' has a wrong offset!");

// Class Engine.VectorFieldComponent
// 0x0030 (0x05A0 - 0x0570)
class UVectorFieldComponent final : public UPrimitiveComponent
{
public:
	class UVectorField*                           VectorField;                                       // 0x0570(0x0008)(Edit, BlueprintVisible, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         Intensity;                                         // 0x0578(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         Tightness;                                         // 0x057C(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bPreviewVectorField : 1;                           // 0x0580(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Transient, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_581[0x1F];                                     // 0x0581(0x001F)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void SetIntensity(float NewIntensity);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"VectorFieldComponent">();
	}
	static class UVectorFieldComponent* GetDefaultObj()
	{
		return GetDefaultObjImpl<UVectorFieldComponent>();
	}
};
static_assert(alignof(UVectorFieldComponent) == 0x000010, "Wrong alignment on UVectorFieldComponent");
static_assert(sizeof(UVectorFieldComponent) == 0x0005A0, "Wrong size on UVectorFieldComponent");
static_assert(offsetof(UVectorFieldComponent, VectorField) == 0x000570, "Member 'UVectorFieldComponent::VectorField' has a wrong offset!");
static_assert(offsetof(UVectorFieldComponent, Intensity) == 0x000578, "Member 'UVectorFieldComponent::Intensity' has a wrong offset!");
static_assert(offsetof(UVectorFieldComponent, Tightness) == 0x00057C, "Member 'UVectorFieldComponent::Tightness' has a wrong offset!");

// Class Engine.VectorFieldStatic
// 0x0050 (0x00B8 - 0x0068)
class UVectorFieldStatic final : public UVectorField
{
public:
	int32                                         SizeX;                                             // 0x0068(0x0004)(Edit, ZeroConstructor, EditConst, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         SizeY;                                             // 0x006C(0x0004)(Edit, ZeroConstructor, EditConst, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         SizeZ;                                             // 0x0070(0x0004)(Edit, ZeroConstructor, EditConst, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bAllowCPUAccess;                                   // 0x0074(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_75[0x43];                                      // 0x0075(0x0043)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"VectorFieldStatic">();
	}
	static class UVectorFieldStatic* GetDefaultObj()
	{
		return GetDefaultObjImpl<UVectorFieldStatic>();
	}
};
static_assert(alignof(UVectorFieldStatic) == 0x000008, "Wrong alignment on UVectorFieldStatic");
static_assert(sizeof(UVectorFieldStatic) == 0x0000B8, "Wrong size on UVectorFieldStatic");
static_assert(offsetof(UVectorFieldStatic, SizeX) == 0x000068, "Member 'UVectorFieldStatic::SizeX' has a wrong offset!");
static_assert(offsetof(UVectorFieldStatic, SizeY) == 0x00006C, "Member 'UVectorFieldStatic::SizeY' has a wrong offset!");
static_assert(offsetof(UVectorFieldStatic, SizeZ) == 0x000070, "Member 'UVectorFieldStatic::SizeZ' has a wrong offset!");
static_assert(offsetof(UVectorFieldStatic, bAllowCPUAccess) == 0x000074, "Member 'UVectorFieldStatic::bAllowCPUAccess' has a wrong offset!");

// Class Engine.VisualLoggerDebugSnapshotInterface
// 0x0000 (0x0000 - 0x0000)
class IVisualLoggerDebugSnapshotInterface final
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"VisualLoggerDebugSnapshotInterface">();
	}
	static class IVisualLoggerDebugSnapshotInterface* GetDefaultObj()
	{
		return GetDefaultObjImpl<IVisualLoggerDebugSnapshotInterface>();
	}

	class UObject* AsUObject()
	{
		return reinterpret_cast<UObject*>(this);
	}
	const class UObject* AsUObject() const
	{
		return reinterpret_cast<const UObject*>(this);
	}
};
static_assert(alignof(IVisualLoggerDebugSnapshotInterface) == 0x000001, "Wrong alignment on IVisualLoggerDebugSnapshotInterface");
static_assert(sizeof(IVisualLoggerDebugSnapshotInterface) == 0x000001, "Wrong size on IVisualLoggerDebugSnapshotInterface");

// Class Engine.WindDirectionalSourceComponent
// 0x0020 (0x02C0 - 0x02A0)
class UWindDirectionalSourceComponent final : public USceneComponent
{
public:
	float                                         Strength;                                          // 0x02A0(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         Speed;                                             // 0x02A4(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         MinGustAmount;                                     // 0x02A8(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         MaxGustAmount;                                     // 0x02AC(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         Radius;                                            // 0x02B0(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bPointWind : 1;                                    // 0x02B4(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_2B5[0xB];                                      // 0x02B5(0x000B)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void SetMaximumGustAmount(float InNewMaxGust);
	void SetMinimumGustAmount(float InNewMinGust);
	void SetRadius(float InNewRadius);
	void SetSpeed(float InNewSpeed);
	void SetStrength(float InNewStrength);
	void SetWindType(EWindSourceType InNewType);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"WindDirectionalSourceComponent">();
	}
	static class UWindDirectionalSourceComponent* GetDefaultObj()
	{
		return GetDefaultObjImpl<UWindDirectionalSourceComponent>();
	}
};
static_assert(alignof(UWindDirectionalSourceComponent) == 0x000010, "Wrong alignment on UWindDirectionalSourceComponent");
static_assert(sizeof(UWindDirectionalSourceComponent) == 0x0002C0, "Wrong size on UWindDirectionalSourceComponent");
static_assert(offsetof(UWindDirectionalSourceComponent, Strength) == 0x0002A0, "Member 'UWindDirectionalSourceComponent::Strength' has a wrong offset!");
static_assert(offsetof(UWindDirectionalSourceComponent, Speed) == 0x0002A4, "Member 'UWindDirectionalSourceComponent::Speed' has a wrong offset!");
static_assert(offsetof(UWindDirectionalSourceComponent, MinGustAmount) == 0x0002A8, "Member 'UWindDirectionalSourceComponent::MinGustAmount' has a wrong offset!");
static_assert(offsetof(UWindDirectionalSourceComponent, MaxGustAmount) == 0x0002AC, "Member 'UWindDirectionalSourceComponent::MaxGustAmount' has a wrong offset!");
static_assert(offsetof(UWindDirectionalSourceComponent, Radius) == 0x0002B0, "Member 'UWindDirectionalSourceComponent::Radius' has a wrong offset!");

// Class Engine.WorldPartitionEditorLoaderAdapter
// 0x0008 (0x0030 - 0x0028)
class UWorldPartitionEditorLoaderAdapter final : public UObject
{
public:
	uint8                                         Pad_28[0x8];                                       // 0x0028(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"WorldPartitionEditorLoaderAdapter">();
	}
	static class UWorldPartitionEditorLoaderAdapter* GetDefaultObj()
	{
		return GetDefaultObjImpl<UWorldPartitionEditorLoaderAdapter>();
	}
};
static_assert(alignof(UWorldPartitionEditorLoaderAdapter) == 0x000008, "Wrong alignment on UWorldPartitionEditorLoaderAdapter");
static_assert(sizeof(UWorldPartitionEditorLoaderAdapter) == 0x000030, "Wrong size on UWorldPartitionEditorLoaderAdapter");

// Class Engine.RuntimeHashExternalStreamingObjectBase
// 0x00F0 (0x0118 - 0x0028)
class URuntimeHashExternalStreamingObjectBase : public UObject
{
public:
	TMap<class FName, class FName>                SubObjectsToCellRemapping;                         // 0x0028(0x0050)(NativeAccessSpecifierPublic)
	TSoftObjectPtr<class UWorld>                  OwningWorld;                                       // 0x0078(0x0028)(Protected, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	TSoftObjectPtr<class UWorld>                  OuterWorld;                                        // 0x00A0(0x0028)(Protected, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	TMap<class FName, class FName>                CellToLevelStreamingPackage;                       // 0x00C8(0x0050)(Protected, NativeAccessSpecifierProtected)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"RuntimeHashExternalStreamingObjectBase">();
	}
	static class URuntimeHashExternalStreamingObjectBase* GetDefaultObj()
	{
		return GetDefaultObjImpl<URuntimeHashExternalStreamingObjectBase>();
	}
};
static_assert(alignof(URuntimeHashExternalStreamingObjectBase) == 0x000008, "Wrong alignment on URuntimeHashExternalStreamingObjectBase");
static_assert(sizeof(URuntimeHashExternalStreamingObjectBase) == 0x000118, "Wrong size on URuntimeHashExternalStreamingObjectBase");
static_assert(offsetof(URuntimeHashExternalStreamingObjectBase, SubObjectsToCellRemapping) == 0x000028, "Member 'URuntimeHashExternalStreamingObjectBase::SubObjectsToCellRemapping' has a wrong offset!");
static_assert(offsetof(URuntimeHashExternalStreamingObjectBase, OwningWorld) == 0x000078, "Member 'URuntimeHashExternalStreamingObjectBase::OwningWorld' has a wrong offset!");
static_assert(offsetof(URuntimeHashExternalStreamingObjectBase, OuterWorld) == 0x0000A0, "Member 'URuntimeHashExternalStreamingObjectBase::OuterWorld' has a wrong offset!");
static_assert(offsetof(URuntimeHashExternalStreamingObjectBase, CellToLevelStreamingPackage) == 0x0000C8, "Member 'URuntimeHashExternalStreamingObjectBase::CellToLevelStreamingPackage' has a wrong offset!");

// Class Engine.DrawSphereComponent
// 0x0000 (0x05A0 - 0x05A0)
class UDrawSphereComponent final : public USphereComponent
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"DrawSphereComponent">();
	}
	static class UDrawSphereComponent* GetDefaultObj()
	{
		return GetDefaultObjImpl<UDrawSphereComponent>();
	}
};
static_assert(alignof(UDrawSphereComponent) == 0x000010, "Wrong alignment on UDrawSphereComponent");
static_assert(sizeof(UDrawSphereComponent) == 0x0005A0, "Wrong size on UDrawSphereComponent");

// Class Engine.RuntimeHashSetExternalStreamingObject
// 0x0028 (0x0140 - 0x0118)
class URuntimeHashSetExternalStreamingObject final : public URuntimeHashExternalStreamingObjectBase
{
public:
	TArray<class UWorldPartitionRuntimeCell*>     NonSpatiallyLoadedRuntimeCells;                    // 0x0118(0x0010)(ZeroConstructor, UObjectWrapper, NativeAccessSpecifierPublic)
	TArray<class UWorldPartitionRuntimeCell*>     SpatiallyLoadedRuntimeCells;                       // 0x0128(0x0010)(ZeroConstructor, UObjectWrapper, NativeAccessSpecifierPublic)
	uint8                                         Pad_138[0x8];                                      // 0x0138(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"RuntimeHashSetExternalStreamingObject">();
	}
	static class URuntimeHashSetExternalStreamingObject* GetDefaultObj()
	{
		return GetDefaultObjImpl<URuntimeHashSetExternalStreamingObject>();
	}
};
static_assert(alignof(URuntimeHashSetExternalStreamingObject) == 0x000008, "Wrong alignment on URuntimeHashSetExternalStreamingObject");
static_assert(sizeof(URuntimeHashSetExternalStreamingObject) == 0x000140, "Wrong size on URuntimeHashSetExternalStreamingObject");
static_assert(offsetof(URuntimeHashSetExternalStreamingObject, NonSpatiallyLoadedRuntimeCells) == 0x000118, "Member 'URuntimeHashSetExternalStreamingObject::NonSpatiallyLoadedRuntimeCells' has a wrong offset!");
static_assert(offsetof(URuntimeHashSetExternalStreamingObject, SpatiallyLoadedRuntimeCells) == 0x000128, "Member 'URuntimeHashSetExternalStreamingObject::SpatiallyLoadedRuntimeCells' has a wrong offset!");

// Class Engine.HierarchicalLODSetup
// 0x0038 (0x0060 - 0x0028)
class UHierarchicalLODSetup final : public UObject
{
public:
	TArray<struct FHierarchicalSimplification>    HierarchicalLODSetup;                              // 0x0028(0x0010)(Edit, ZeroConstructor, NativeAccessSpecifierPublic)
	TSoftObjectPtr<class UMaterialInterface>      OverrideBaseMaterial;                              // 0x0038(0x0028)(Edit, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"HierarchicalLODSetup">();
	}
	static class UHierarchicalLODSetup* GetDefaultObj()
	{
		return GetDefaultObjImpl<UHierarchicalLODSetup>();
	}
};
static_assert(alignof(UHierarchicalLODSetup) == 0x000008, "Wrong alignment on UHierarchicalLODSetup");
static_assert(sizeof(UHierarchicalLODSetup) == 0x000060, "Wrong size on UHierarchicalLODSetup");
static_assert(offsetof(UHierarchicalLODSetup, HierarchicalLODSetup) == 0x000028, "Member 'UHierarchicalLODSetup::HierarchicalLODSetup' has a wrong offset!");
static_assert(offsetof(UHierarchicalLODSetup, OverrideBaseMaterial) == 0x000038, "Member 'UHierarchicalLODSetup::OverrideBaseMaterial' has a wrong offset!");

// Class Engine.WorldSettings
// 0x0220 (0x04C0 - 0x02A0)
class AWorldSettings final : public AInfo
{
public:
	uint8                                         Pad_2A0[0x8];                                      // 0x02A0(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	int32                                         VisibilityCellSize;                                // 0x02A8(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EVisibilityAggressiveness                     VisibilityAggressiveness;                          // 0x02AC(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bPrecomputeVisibility : 1;                         // 0x02AD(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bPlaceCellsOnlyAlongCameraTracks : 1;              // 0x02AD(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bEnableWorldBoundsChecks : 1;                      // 0x02AD(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bEnableNavigationSystem : 1;                       // 0x02AD(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (BlueprintVisible, BlueprintReadOnly, Config, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
	uint8                                         bEnableAISystem : 1;                               // 0x02AD(0x0001)(BitIndex: 0x04, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, Config, NoDestructor, AdvancedDisplay, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
	uint8                                         bEnableWorldComposition : 1;                       // 0x02AD(0x0001)(BitIndex: 0x05, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bUseClientSideLevelStreamingVolumes : 1;           // 0x02AD(0x0001)(BitIndex: 0x06, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bEnableWorldOriginRebasing : 1;                    // 0x02AD(0x0001)(BitIndex: 0x07, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bWorldGravitySet : 1;                              // 0x02AE(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Transient, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bGlobalGravitySet : 1;                             // 0x02AE(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bMinimizeBSPSections : 1;                          // 0x02AE(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Edit, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bForceNoPrecomputedLighting : 1;                   // 0x02AE(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (Edit, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bHighPriorityLoading : 1;                          // 0x02AE(0x0001)(BitIndex: 0x04, PropSize: 0x0001 (Net, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bHighPriorityLoadingLocal : 1;                     // 0x02AE(0x0001)(BitIndex: 0x05, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bOverrideDefaultBroadphaseSettings : 1;            // 0x02AE(0x0001)(BitIndex: 0x06, PropSize: 0x0001 (Edit, Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bGenerateSingleClusterForLevel : 1;                // 0x02AE(0x0001)(BitIndex: 0x07, PropSize: 0x0001 (Edit, Config, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bReuseAddressAndPort : 1;                          // 0x02AF(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	TSoftClassPtr<class UClass>                   AISystemClass;                                     // 0x02B0(0x0028)(Edit, BlueprintVisible, BlueprintReadOnly, AdvancedDisplay, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector                                LevelInstancePivotOffset;                          // 0x02D8(0x0018)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UNavigationSystemConfig*                NavigationSystemConfig;                            // 0x02F0(0x0008)(Edit, BlueprintVisible, ExportObject, BlueprintReadOnly, ZeroConstructor, InstancedReference, NoClear, NoDestructor, AdvancedDisplay, Protected, PersistentInstance, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	class UNavigationSystemConfig*                NavigationSystemConfigOverride;                    // 0x02F8(0x0008)(ZeroConstructor, Transient, NoDestructor, Protected, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	class UWorldPartition*                        WorldPartition;                                    // 0x0300(0x0008)(Edit, ExportObject, ZeroConstructor, EditConst, InstancedReference, NoDestructor, Protected, PersistentInstance, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	TArray<class UDataLayerAsset*>                BaseNavmeshDataLayers;                             // 0x0308(0x0010)(Edit, ZeroConstructor, UObjectWrapper, NativeAccessSpecifierPublic)
	float                                         WorldToMeters;                                     // 0x0318(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         KillZ;                                             // 0x031C(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TSubclassOf<class UDamageType>                KillZDamageType;                                   // 0x0320(0x0008)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, NoDestructor, AdvancedDisplay, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         WorldGravityZ;                                     // 0x0328(0x0004)(Net, ZeroConstructor, Transient, IsPlainOldData, RepNotify, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         GlobalGravityZ;                                    // 0x032C(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TSubclassOf<class ADefaultPhysicsVolume>      DefaultPhysicsVolumeClass;                         // 0x0330(0x0008)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, NoClear, NoDestructor, AdvancedDisplay, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TSubclassOf<class UPhysicsCollisionHandler>   PhysicsCollisionHandlerClass;                      // 0x0338(0x0008)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, NoDestructor, AdvancedDisplay, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TSubclassOf<class AGameModeBase>              DefaultGameMode;                                   // 0x0340(0x0008)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TSubclassOf<class AGameNetworkManager>        GameNetworkManagerClass;                           // 0x0348(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         PackedLightAndShadowMapTextureSize;                // 0x0350(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_354[0x4];                                      // 0x0354(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	struct FVector                                DefaultColorScale;                                 // 0x0358(0x0018)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         DefaultMaxDistanceFieldOcclusionDistance;          // 0x0370(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         GlobalDistanceFieldViewDistance;                   // 0x0374(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         DynamicIndirectShadowsSelfShadowingIntensity;      // 0x0378(0x0004)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FNaniteSettings                        NaniteSettings;                                    // 0x037C(0x0001)(Edit, Net, Config, RepNotify, NoDestructor, NativeAccessSpecifierPublic)
	uint8                                         Pad_37D[0x3];                                      // 0x037D(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	struct FReverbSettings                        DefaultReverbSettings;                             // 0x0380(0x0020)(Edit, Config, NoDestructor, NativeAccessSpecifierPublic)
	struct FInteriorSettings                      DefaultAmbientZoneSettings;                        // 0x03A0(0x0024)(Edit, Config, NoDestructor, NativeAccessSpecifierPublic)
	uint8                                         Pad_3C4[0x4];                                      // 0x03C4(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	class USoundMix*                              DefaultBaseSoundMix;                               // 0x03C8(0x0008)(Edit, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         TimeDilation;                                      // 0x03D0(0x0004)(Net, ZeroConstructor, Transient, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         CinematicTimeDilation;                             // 0x03D4(0x0004)(Net, ZeroConstructor, Transient, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         DemoPlayTimeDilation;                              // 0x03D8(0x0004)(ZeroConstructor, Transient, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         MinGlobalTimeDilation;                             // 0x03DC(0x0004)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         MaxGlobalTimeDilation;                             // 0x03E0(0x0004)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         MinUndilatedFrameTime;                             // 0x03E4(0x0004)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         MaxUndilatedFrameTime;                             // 0x03E8(0x0004)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_3EC[0x4];                                      // 0x03EC(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	struct FBroadphaseSettings                    BroadphaseSettings;                                // 0x03F0(0x0080)(Edit, Config, NoDestructor, NativeAccessSpecifierPublic)
	TArray<struct FNetViewer>                     ReplicationViewers;                                // 0x0470(0x0010)(ZeroConstructor, NativeAccessSpecifierPublic)
	TArray<class UAssetUserData*>                 AssetUserData;                                     // 0x0480(0x0010)(ExportObject, ZeroConstructor, ContainsInstancedReference, Protected, UObjectWrapper, NativeAccessSpecifierProtected)
	class APlayerState*                           PauserPlayerState;                                 // 0x0490(0x0008)(Net, ZeroConstructor, Transient, NoDestructor, Protected, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	int32                                         MaxNumberOfBookmarks;                              // 0x0498(0x0004)(ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_49C[0x4];                                      // 0x049C(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	TSubclassOf<class UBookmarkBase>              DefaultBookmarkClass;                              // 0x04A0(0x0008)(ZeroConstructor, Config, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	TArray<class UBookmarkBase*>                  BookmarkArray;                                     // 0x04A8(0x0010)(ZeroConstructor, UObjectWrapper, NativeAccessSpecifierPrivate)
	TSubclassOf<class UBookmarkBase>              LastBookmarkClass;                                 // 0x04B8(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)

public:
	void OnRep_NaniteSettings();
	void OnRep_WorldGravityZ();

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"WorldSettings">();
	}
	static class AWorldSettings* GetDefaultObj()
	{
		return GetDefaultObjImpl<AWorldSettings>();
	}
};
static_assert(alignof(AWorldSettings) == 0x000008, "Wrong alignment on AWorldSettings");
static_assert(sizeof(AWorldSettings) == 0x0004C0, "Wrong size on AWorldSettings");
static_assert(offsetof(AWorldSettings, VisibilityCellSize) == 0x0002A8, "Member 'AWorldSettings::VisibilityCellSize' has a wrong offset!");
static_assert(offsetof(AWorldSettings, VisibilityAggressiveness) == 0x0002AC, "Member 'AWorldSettings::VisibilityAggressiveness' has a wrong offset!");
static_assert(offsetof(AWorldSettings, AISystemClass) == 0x0002B0, "Member 'AWorldSettings::AISystemClass' has a wrong offset!");
static_assert(offsetof(AWorldSettings, LevelInstancePivotOffset) == 0x0002D8, "Member 'AWorldSettings::LevelInstancePivotOffset' has a wrong offset!");
static_assert(offsetof(AWorldSettings, NavigationSystemConfig) == 0x0002F0, "Member 'AWorldSettings::NavigationSystemConfig' has a wrong offset!");
static_assert(offsetof(AWorldSettings, NavigationSystemConfigOverride) == 0x0002F8, "Member 'AWorldSettings::NavigationSystemConfigOverride' has a wrong offset!");
static_assert(offsetof(AWorldSettings, WorldPartition) == 0x000300, "Member 'AWorldSettings::WorldPartition' has a wrong offset!");
static_assert(offsetof(AWorldSettings, BaseNavmeshDataLayers) == 0x000308, "Member 'AWorldSettings::BaseNavmeshDataLayers' has a wrong offset!");
static_assert(offsetof(AWorldSettings, WorldToMeters) == 0x000318, "Member 'AWorldSettings::WorldToMeters' has a wrong offset!");
static_assert(offsetof(AWorldSettings, KillZ) == 0x00031C, "Member 'AWorldSettings::KillZ' has a wrong offset!");
static_assert(offsetof(AWorldSettings, KillZDamageType) == 0x000320, "Member 'AWorldSettings::KillZDamageType' has a wrong offset!");
static_assert(offsetof(AWorldSettings, WorldGravityZ) == 0x000328, "Member 'AWorldSettings::WorldGravityZ' has a wrong offset!");
static_assert(offsetof(AWorldSettings, GlobalGravityZ) == 0x00032C, "Member 'AWorldSettings::GlobalGravityZ' has a wrong offset!");
static_assert(offsetof(AWorldSettings, DefaultPhysicsVolumeClass) == 0x000330, "Member 'AWorldSettings::DefaultPhysicsVolumeClass' has a wrong offset!");
static_assert(offsetof(AWorldSettings, PhysicsCollisionHandlerClass) == 0x000338, "Member 'AWorldSettings::PhysicsCollisionHandlerClass' has a wrong offset!");
static_assert(offsetof(AWorldSettings, DefaultGameMode) == 0x000340, "Member 'AWorldSettings::DefaultGameMode' has a wrong offset!");
static_assert(offsetof(AWorldSettings, GameNetworkManagerClass) == 0x000348, "Member 'AWorldSettings::GameNetworkManagerClass' has a wrong offset!");
static_assert(offsetof(AWorldSettings, PackedLightAndShadowMapTextureSize) == 0x000350, "Member 'AWorldSettings::PackedLightAndShadowMapTextureSize' has a wrong offset!");
static_assert(offsetof(AWorldSettings, DefaultColorScale) == 0x000358, "Member 'AWorldSettings::DefaultColorScale' has a wrong offset!");
static_assert(offsetof(AWorldSettings, DefaultMaxDistanceFieldOcclusionDistance) == 0x000370, "Member 'AWorldSettings::DefaultMaxDistanceFieldOcclusionDistance' has a wrong offset!");
static_assert(offsetof(AWorldSettings, GlobalDistanceFieldViewDistance) == 0x000374, "Member 'AWorldSettings::GlobalDistanceFieldViewDistance' has a wrong offset!");
static_assert(offsetof(AWorldSettings, DynamicIndirectShadowsSelfShadowingIntensity) == 0x000378, "Member 'AWorldSettings::DynamicIndirectShadowsSelfShadowingIntensity' has a wrong offset!");
static_assert(offsetof(AWorldSettings, NaniteSettings) == 0x00037C, "Member 'AWorldSettings::NaniteSettings' has a wrong offset!");
static_assert(offsetof(AWorldSettings, DefaultReverbSettings) == 0x000380, "Member 'AWorldSettings::DefaultReverbSettings' has a wrong offset!");
static_assert(offsetof(AWorldSettings, DefaultAmbientZoneSettings) == 0x0003A0, "Member 'AWorldSettings::DefaultAmbientZoneSettings' has a wrong offset!");
static_assert(offsetof(AWorldSettings, DefaultBaseSoundMix) == 0x0003C8, "Member 'AWorldSettings::DefaultBaseSoundMix' has a wrong offset!");
static_assert(offsetof(AWorldSettings, TimeDilation) == 0x0003D0, "Member 'AWorldSettings::TimeDilation' has a wrong offset!");
static_assert(offsetof(AWorldSettings, CinematicTimeDilation) == 0x0003D4, "Member 'AWorldSettings::CinematicTimeDilation' has a wrong offset!");
static_assert(offsetof(AWorldSettings, DemoPlayTimeDilation) == 0x0003D8, "Member 'AWorldSettings::DemoPlayTimeDilation' has a wrong offset!");
static_assert(offsetof(AWorldSettings, MinGlobalTimeDilation) == 0x0003DC, "Member 'AWorldSettings::MinGlobalTimeDilation' has a wrong offset!");
static_assert(offsetof(AWorldSettings, MaxGlobalTimeDilation) == 0x0003E0, "Member 'AWorldSettings::MaxGlobalTimeDilation' has a wrong offset!");
static_assert(offsetof(AWorldSettings, MinUndilatedFrameTime) == 0x0003E4, "Member 'AWorldSettings::MinUndilatedFrameTime' has a wrong offset!");
static_assert(offsetof(AWorldSettings, MaxUndilatedFrameTime) == 0x0003E8, "Member 'AWorldSettings::MaxUndilatedFrameTime' has a wrong offset!");
static_assert(offsetof(AWorldSettings, BroadphaseSettings) == 0x0003F0, "Member 'AWorldSettings::BroadphaseSettings' has a wrong offset!");
static_assert(offsetof(AWorldSettings, ReplicationViewers) == 0x000470, "Member 'AWorldSettings::ReplicationViewers' has a wrong offset!");
static_assert(offsetof(AWorldSettings, AssetUserData) == 0x000480, "Member 'AWorldSettings::AssetUserData' has a wrong offset!");
static_assert(offsetof(AWorldSettings, PauserPlayerState) == 0x000490, "Member 'AWorldSettings::PauserPlayerState' has a wrong offset!");
static_assert(offsetof(AWorldSettings, MaxNumberOfBookmarks) == 0x000498, "Member 'AWorldSettings::MaxNumberOfBookmarks' has a wrong offset!");
static_assert(offsetof(AWorldSettings, DefaultBookmarkClass) == 0x0004A0, "Member 'AWorldSettings::DefaultBookmarkClass' has a wrong offset!");
static_assert(offsetof(AWorldSettings, BookmarkArray) == 0x0004A8, "Member 'AWorldSettings::BookmarkArray' has a wrong offset!");
static_assert(offsetof(AWorldSettings, LastBookmarkClass) == 0x0004B8, "Member 'AWorldSettings::LastBookmarkClass' has a wrong offset!");

// Class Engine.Texture2DArray
// 0x00A0 (0x0270 - 0x01D0)
class UTexture2DArray final : public UTexture
{
public:
	uint8                                         Pad_1C8[0x98];                                     // 0x01C8(0x0098)(Fixing Size After Last Property [ Dumper-7 ])
	ETextureAddress                               AddressX;                                          // 0x0260(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	ETextureAddress                               AddressY;                                          // 0x0261(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	ETextureAddress                               AddressZ;                                          // 0x0262(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_263[0xD];                                      // 0x0263(0x000D)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"Texture2DArray">();
	}
	static class UTexture2DArray* GetDefaultObj()
	{
		return GetDefaultObjImpl<UTexture2DArray>();
	}
};
static_assert(alignof(UTexture2DArray) == 0x000010, "Wrong alignment on UTexture2DArray");
static_assert(sizeof(UTexture2DArray) == 0x000270, "Wrong size on UTexture2DArray");
static_assert(offsetof(UTexture2DArray, AddressX) == 0x000260, "Member 'UTexture2DArray::AddressX' has a wrong offset!");
static_assert(offsetof(UTexture2DArray, AddressY) == 0x000261, "Member 'UTexture2DArray::AddressY' has a wrong offset!");
static_assert(offsetof(UTexture2DArray, AddressZ) == 0x000262, "Member 'UTexture2DArray::AddressZ' has a wrong offset!");

// Class Engine.InputComponent
// 0x0088 (0x0130 - 0x00A8)
class UInputComponent : public UActorComponent
{
public:
	uint8                                         Pad_A8[0x70];                                      // 0x00A8(0x0070)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<struct FCachedKeyToActionInfo>         CachedKeyToActionInfo;                             // 0x0118(0x0010)(ZeroConstructor, Transient, DuplicateTransient, NativeAccessSpecifierPrivate)
	uint8                                         Pad_128[0x8];                                      // 0x0128(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void OnInputOwnerEndPlayed(class AActor* InOwner, EEndPlayReason EndPlayReason);

	float GetControllerAnalogKeyState(const struct FKey& Key) const;
	void GetControllerAnalogStickState(EControllerAnalogStick WhichStick, float* StickX, float* StickY) const;
	float GetControllerKeyTimeDown(const struct FKey& Key) const;
	void GetControllerMouseDelta(float* DeltaX, float* DeltaY) const;
	struct FVector GetControllerVectorKeyState(const struct FKey& Key) const;
	void GetTouchState(int32 FingerIndex, float* LocationX, float* LocationY, bool* bIsCurrentlyPressed) const;
	bool IsControllerKeyDown(const struct FKey& Key) const;
	bool WasControllerKeyJustPressed(const struct FKey& Key) const;
	bool WasControllerKeyJustReleased(const struct FKey& Key) const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"InputComponent">();
	}
	static class UInputComponent* GetDefaultObj()
	{
		return GetDefaultObjImpl<UInputComponent>();
	}
};
static_assert(alignof(UInputComponent) == 0x000008, "Wrong alignment on UInputComponent");
static_assert(sizeof(UInputComponent) == 0x000130, "Wrong size on UInputComponent");
static_assert(offsetof(UInputComponent, CachedKeyToActionInfo) == 0x000118, "Member 'UInputComponent::CachedKeyToActionInfo' has a wrong offset!");

// Class Engine.Level
// 0x02F0 (0x0318 - 0x0028)
class ULevel final : public UObject
{
public:
	uint8                                         Pad_28[0x70];                                      // 0x0028(0x0070)(Fixing Size After Last Property [ Dumper-7 ])
	class TArray<class AActor*>                   Actors;                                            // 0x0098(0x0010)(THIS IS THE ARRAY YOU'RE LOOKING FOR! [NOT AUTO-GENERATED PROPERTY])
	uint8                                         Pad_A8[0x10];                                      // 0x00A8(0x0010)(Fixing Size After Last Property [ Dumper-7 ])
	class UWorld*                                 OwningWorld;                                       // 0x00B8(0x0008)(ZeroConstructor, Transient, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UModel*                                 Model;                                             // 0x00C0(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TArray<class UModelComponent*>                ModelComponents;                                   // 0x00C8(0x0010)(ExportObject, ZeroConstructor, ContainsInstancedReference, UObjectWrapper, NativeAccessSpecifierPublic)
	class ULevelActorContainer*                   ActorCluster;                                      // 0x00D8(0x0008)(ExportObject, ZeroConstructor, Transient, InstancedReference, DuplicateTransient, NonTransactional, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         NumTextureStreamingUnbuiltComponents;              // 0x00E0(0x0004)(ZeroConstructor, IsPlainOldData, NonTransactional, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         NumTextureStreamingDirtyResources;                 // 0x00E4(0x0004)(ZeroConstructor, IsPlainOldData, NonTransactional, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class ALevelScriptActor*                      LevelScriptActor;                                  // 0x00E8(0x0008)(ZeroConstructor, NonTransactional, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class ANavigationObjectBase*                  NavListStart;                                      // 0x00F0(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class ANavigationObjectBase*                  NavListEnd;                                        // 0x00F8(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TArray<class UNavigationDataChunk*>           NavDataChunks;                                     // 0x0100(0x0010)(ZeroConstructor, UObjectWrapper, NativeAccessSpecifierPublic)
	float                                         LightmapTotalSize;                                 // 0x0110(0x0004)(Edit, ZeroConstructor, EditConst, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         ShadowmapTotalSize;                                // 0x0114(0x0004)(Edit, ZeroConstructor, EditConst, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TArray<struct FVector>                        StaticNavigableGeometry;                           // 0x0118(0x0010)(ZeroConstructor, NativeAccessSpecifierPublic)
	TArray<struct FGuid>                          StreamingTextureGuids;                             // 0x0128(0x0010)(ZeroConstructor, NativeAccessSpecifierPublic)
	TArray<class FName>                           StreamingTextures;                                 // 0x0138(0x0010)(ZeroConstructor, NativeAccessSpecifierPublic)
	uint32                                        PackedTextureStreamingQualityLevelFeatureLevel;    // 0x0148(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_14C[0xC4];                                     // 0x014C(0x00C4)(Fixing Size After Last Property [ Dumper-7 ])
	struct FGuid                                  LevelBuildDataId;                                  // 0x0210(0x0010)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UMapBuildDataRegistry*                  MapBuildData;                                      // 0x0220(0x0008)(ZeroConstructor, NoDestructor, NonPIEDuplicateTransient, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FIntVector                             LightBuildLevelOffset;                             // 0x0228(0x000C)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bIsLightingScenario : 1;                           // 0x0234(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         BitPad_234_1 : 2;                                  // 0x0234(0x0001)(Fixing Bit-Field Size Between Bits [ Dumper-7 ])
	uint8                                         bTextureStreamingRotationChanged : 1;              // 0x0234(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bStaticComponentsRegisteredInStreamingManager : 1; // 0x0234(0x0001)(BitIndex: 0x04, PropSize: 0x0001 (Transient, DuplicateTransient, NonTransactional, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bIsVisible : 1;                                    // 0x0234(0x0001)(BitIndex: 0x05, PropSize: 0x0001 (Transient, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         BitPad_234_6 : 2;                                  // 0x0234(0x0001)(Fixing Bit-Field Size For New Byte [ Dumper-7 ])
	uint8                                         Pad_235[0x1];                                      // 0x0235(0x0001)(Fixing Size After Last Property [ Dumper-7 ])
	uint8                                         BitPad_236_0 : 7;                                  // 0x0236(0x0001)(Fixing Bit-Field Size Between Bits [ Dumper-7 ])
	uint8                                         bIsPartitioned : 1;                                // 0x0236(0x0001)(BitIndex: 0x07, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_237[0x69];                                     // 0x0237(0x0069)(Fixing Size After Last Property [ Dumper-7 ])
	class AWorldSettings*                         WorldSettings;                                     // 0x02A0(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	class AWorldDataLayers*                       WorldDataLayers;                                   // 0x02A8(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	TSoftObjectPtr<class UWorldPartitionRuntimeCell> WorldPartitionRuntimeCell;                      // 0x02B0(0x0028)(UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_2D8[0x8];                                      // 0x02D8(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<class UAssetUserData*>                 AssetUserData;                                     // 0x02E0(0x0010)(ExportObject, ZeroConstructor, ContainsInstancedReference, Protected, UObjectWrapper, NativeAccessSpecifierProtected)
	uint8                                         Pad_2F0[0x10];                                     // 0x02F0(0x0010)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<struct FReplicatedStaticActorDestructionInfo> DestroyedReplicatedStaticActors;            // 0x0300(0x0010)(ZeroConstructor, Transient, NativeAccessSpecifierPrivate)
	uint8                                         Pad_310[0x8];                                      // 0x0310(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"Level">();
	}
	static class ULevel* GetDefaultObj()
	{
		return GetDefaultObjImpl<ULevel>();
	}
};
static_assert(alignof(ULevel) == 0x000008, "Wrong alignment on ULevel");
static_assert(sizeof(ULevel) == 0x000318, "Wrong size on ULevel");
static_assert(offsetof(ULevel, Actors) == 0x000098, "Member 'ULevel::Actors' has a wrong offset!");
static_assert(offsetof(ULevel, OwningWorld) == 0x0000B8, "Member 'ULevel::OwningWorld' has a wrong offset!");
static_assert(offsetof(ULevel, Model) == 0x0000C0, "Member 'ULevel::Model' has a wrong offset!");
static_assert(offsetof(ULevel, ModelComponents) == 0x0000C8, "Member 'ULevel::ModelComponents' has a wrong offset!");
static_assert(offsetof(ULevel, ActorCluster) == 0x0000D8, "Member 'ULevel::ActorCluster' has a wrong offset!");
static_assert(offsetof(ULevel, NumTextureStreamingUnbuiltComponents) == 0x0000E0, "Member 'ULevel::NumTextureStreamingUnbuiltComponents' has a wrong offset!");
static_assert(offsetof(ULevel, NumTextureStreamingDirtyResources) == 0x0000E4, "Member 'ULevel::NumTextureStreamingDirtyResources' has a wrong offset!");
static_assert(offsetof(ULevel, LevelScriptActor) == 0x0000E8, "Member 'ULevel::LevelScriptActor' has a wrong offset!");
static_assert(offsetof(ULevel, NavListStart) == 0x0000F0, "Member 'ULevel::NavListStart' has a wrong offset!");
static_assert(offsetof(ULevel, NavListEnd) == 0x0000F8, "Member 'ULevel::NavListEnd' has a wrong offset!");
static_assert(offsetof(ULevel, NavDataChunks) == 0x000100, "Member 'ULevel::NavDataChunks' has a wrong offset!");
static_assert(offsetof(ULevel, LightmapTotalSize) == 0x000110, "Member 'ULevel::LightmapTotalSize' has a wrong offset!");
static_assert(offsetof(ULevel, ShadowmapTotalSize) == 0x000114, "Member 'ULevel::ShadowmapTotalSize' has a wrong offset!");
static_assert(offsetof(ULevel, StaticNavigableGeometry) == 0x000118, "Member 'ULevel::StaticNavigableGeometry' has a wrong offset!");
static_assert(offsetof(ULevel, StreamingTextureGuids) == 0x000128, "Member 'ULevel::StreamingTextureGuids' has a wrong offset!");
static_assert(offsetof(ULevel, StreamingTextures) == 0x000138, "Member 'ULevel::StreamingTextures' has a wrong offset!");
static_assert(offsetof(ULevel, PackedTextureStreamingQualityLevelFeatureLevel) == 0x000148, "Member 'ULevel::PackedTextureStreamingQualityLevelFeatureLevel' has a wrong offset!");
static_assert(offsetof(ULevel, LevelBuildDataId) == 0x000210, "Member 'ULevel::LevelBuildDataId' has a wrong offset!");
static_assert(offsetof(ULevel, MapBuildData) == 0x000220, "Member 'ULevel::MapBuildData' has a wrong offset!");
static_assert(offsetof(ULevel, LightBuildLevelOffset) == 0x000228, "Member 'ULevel::LightBuildLevelOffset' has a wrong offset!");
static_assert(offsetof(ULevel, WorldSettings) == 0x0002A0, "Member 'ULevel::WorldSettings' has a wrong offset!");
static_assert(offsetof(ULevel, WorldDataLayers) == 0x0002A8, "Member 'ULevel::WorldDataLayers' has a wrong offset!");
static_assert(offsetof(ULevel, WorldPartitionRuntimeCell) == 0x0002B0, "Member 'ULevel::WorldPartitionRuntimeCell' has a wrong offset!");
static_assert(offsetof(ULevel, AssetUserData) == 0x0002E0, "Member 'ULevel::AssetUserData' has a wrong offset!");
static_assert(offsetof(ULevel, DestroyedReplicatedStaticActors) == 0x000300, "Member 'ULevel::DestroyedReplicatedStaticActors' has a wrong offset!");

// Class Engine.ActorFolder
// 0x0000 (0x0028 - 0x0028)
class UActorFolder final : public UObject
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ActorFolder">();
	}
	static class UActorFolder* GetDefaultObj()
	{
		return GetDefaultObjImpl<UActorFolder>();
	}
};
static_assert(alignof(UActorFolder) == 0x000008, "Wrong alignment on UActorFolder");
static_assert(sizeof(UActorFolder) == 0x000028, "Wrong size on UActorFolder");

// Class Engine.ActorPartitionSubsystem
// 0x0000 (0x0030 - 0x0030)
class UActorPartitionSubsystem final : public UWorldSubsystem
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ActorPartitionSubsystem">();
	}
	static class UActorPartitionSubsystem* GetDefaultObj()
	{
		return GetDefaultObjImpl<UActorPartitionSubsystem>();
	}
};
static_assert(alignof(UActorPartitionSubsystem) == 0x000008, "Wrong alignment on UActorPartitionSubsystem");
static_assert(sizeof(UActorPartitionSubsystem) == 0x000030, "Wrong size on UActorPartitionSubsystem");

// Class Engine.AISystemBase
// 0x0038 (0x0060 - 0x0028)
class UAISystemBase : public UObject
{
public:
	struct FSoftClassPath                         AISystemClassName;                                 // 0x0028(0x0020)(Edit, ZeroConstructor, Config, GlobalConfig, NoClear, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	class FName                                   AISystemModuleName;                                // 0x0048(0x0008)(Edit, ZeroConstructor, Config, GlobalConfig, NoClear, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_50[0x8];                                       // 0x0050(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	bool                                          bInstantiateAISystemOnClient;                      // 0x0058(0x0001)(ZeroConstructor, Config, GlobalConfig, NoClear, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_59[0x7];                                       // 0x0059(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AISystemBase">();
	}
	static class UAISystemBase* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAISystemBase>();
	}
};
static_assert(alignof(UAISystemBase) == 0x000008, "Wrong alignment on UAISystemBase");
static_assert(sizeof(UAISystemBase) == 0x000060, "Wrong size on UAISystemBase");
static_assert(offsetof(UAISystemBase, AISystemClassName) == 0x000028, "Member 'UAISystemBase::AISystemClassName' has a wrong offset!");
static_assert(offsetof(UAISystemBase, AISystemModuleName) == 0x000048, "Member 'UAISystemBase::AISystemModuleName' has a wrong offset!");
static_assert(offsetof(UAISystemBase, bInstantiateAISystemOnClient) == 0x000058, "Member 'UAISystemBase::bInstantiateAISystemOnClient' has a wrong offset!");

// Class Engine.AudioBus
// 0x0010 (0x0038 - 0x0028)
class UAudioBus final : public UObject
{
public:
	uint8                                         Pad_28[0x8];                                       // 0x0028(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	EAudioBusChannels                             AudioBusChannels;                                  // 0x0030(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_31[0x7];                                       // 0x0031(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AudioBus">();
	}
	static class UAudioBus* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAudioBus>();
	}
};
static_assert(alignof(UAudioBus) == 0x000008, "Wrong alignment on UAudioBus");
static_assert(sizeof(UAudioBus) == 0x000038, "Wrong size on UAudioBus");
static_assert(offsetof(UAudioBus, AudioBusChannels) == 0x000030, "Member 'UAudioBus::AudioBusChannels' has a wrong offset!");

// Class Engine.NavigationSystemBase
// 0x0000 (0x0028 - 0x0028)
class UNavigationSystemBase : public UObject
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"NavigationSystemBase">();
	}
	static class UNavigationSystemBase* GetDefaultObj()
	{
		return GetDefaultObjImpl<UNavigationSystemBase>();
	}
};
static_assert(alignof(UNavigationSystemBase) == 0x000008, "Wrong alignment on UNavigationSystemBase");
static_assert(sizeof(UNavigationSystemBase) == 0x000028, "Wrong size on UNavigationSystemBase");

// Class Engine.NavigationSystemConfig
// 0x0030 (0x0058 - 0x0028)
class UNavigationSystemConfig : public UObject
{
public:
	struct FSoftClassPath                         NavigationSystemClass;                             // 0x0028(0x0020)(Edit, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FNavAgentSelector                      SupportedAgentsMask;                               // 0x0048(0x0004)(Edit, NoDestructor, NativeAccessSpecifierPublic)
	class FName                                   DefaultAgentName;                                  // 0x004C(0x0008)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bIsOverriden : 1;                                  // 0x0054(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, EditConst, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
	uint8                                         Pad_55[0x3];                                       // 0x0055(0x0003)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"NavigationSystemConfig">();
	}
	static class UNavigationSystemConfig* GetDefaultObj()
	{
		return GetDefaultObjImpl<UNavigationSystemConfig>();
	}
};
static_assert(alignof(UNavigationSystemConfig) == 0x000008, "Wrong alignment on UNavigationSystemConfig");
static_assert(sizeof(UNavigationSystemConfig) == 0x000058, "Wrong size on UNavigationSystemConfig");
static_assert(offsetof(UNavigationSystemConfig, NavigationSystemClass) == 0x000028, "Member 'UNavigationSystemConfig::NavigationSystemClass' has a wrong offset!");
static_assert(offsetof(UNavigationSystemConfig, SupportedAgentsMask) == 0x000048, "Member 'UNavigationSystemConfig::SupportedAgentsMask' has a wrong offset!");
static_assert(offsetof(UNavigationSystemConfig, DefaultAgentName) == 0x00004C, "Member 'UNavigationSystemConfig::DefaultAgentName' has a wrong offset!");

// Class Engine.NullNavSysConfig
// 0x0000 (0x0058 - 0x0058)
class UNullNavSysConfig final : public UNavigationSystemConfig
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"NullNavSysConfig">();
	}
	static class UNullNavSysConfig* GetDefaultObj()
	{
		return GetDefaultObjImpl<UNullNavSysConfig>();
	}
};
static_assert(alignof(UNullNavSysConfig) == 0x000008, "Wrong alignment on UNullNavSysConfig");
static_assert(sizeof(UNullNavSysConfig) == 0x000058, "Wrong size on UNullNavSysConfig");

// Class Engine.AvoidanceManager
// 0x00B8 (0x00E0 - 0x0028)
class UAvoidanceManager final : public UObject
{
public:
	uint8                                         Pad_28[0x8];                                       // 0x0028(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         DefaultTimeToLive;                                 // 0x0030(0x0004)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         LockTimeAfterAvoid;                                // 0x0034(0x0004)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         LockTimeAfterClean;                                // 0x0038(0x0004)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         DeltaTimeToPredict;                                // 0x003C(0x0004)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         ArtificialRadiusExpansion;                         // 0x0040(0x0004)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         TestHeightDifference;                              // 0x0044(0x0004)(ZeroConstructor, Deprecated, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         HeightCheckMargin;                                 // 0x0048(0x0004)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_4C[0x94];                                      // 0x004C(0x0094)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	struct FVector GetAvoidanceVelocityForComponent(class UMovementComponent* MovementComp);
	int32 GetNewAvoidanceUID();
	int32 GetObjectCount();
	bool RegisterMovementComponent(class UMovementComponent* MovementComp, float AvoidanceWeight);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AvoidanceManager">();
	}
	static class UAvoidanceManager* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAvoidanceManager>();
	}
};
static_assert(alignof(UAvoidanceManager) == 0x000008, "Wrong alignment on UAvoidanceManager");
static_assert(sizeof(UAvoidanceManager) == 0x0000E0, "Wrong size on UAvoidanceManager");
static_assert(offsetof(UAvoidanceManager, DefaultTimeToLive) == 0x000030, "Member 'UAvoidanceManager::DefaultTimeToLive' has a wrong offset!");
static_assert(offsetof(UAvoidanceManager, LockTimeAfterAvoid) == 0x000034, "Member 'UAvoidanceManager::LockTimeAfterAvoid' has a wrong offset!");
static_assert(offsetof(UAvoidanceManager, LockTimeAfterClean) == 0x000038, "Member 'UAvoidanceManager::LockTimeAfterClean' has a wrong offset!");
static_assert(offsetof(UAvoidanceManager, DeltaTimeToPredict) == 0x00003C, "Member 'UAvoidanceManager::DeltaTimeToPredict' has a wrong offset!");
static_assert(offsetof(UAvoidanceManager, ArtificialRadiusExpansion) == 0x000040, "Member 'UAvoidanceManager::ArtificialRadiusExpansion' has a wrong offset!");
static_assert(offsetof(UAvoidanceManager, TestHeightDifference) == 0x000044, "Member 'UAvoidanceManager::TestHeightDifference' has a wrong offset!");
static_assert(offsetof(UAvoidanceManager, HeightCheckMargin) == 0x000048, "Member 'UAvoidanceManager::HeightCheckMargin' has a wrong offset!");

// Class Engine.AudioWidgetSubsystem
// 0x0000 (0x0030 - 0x0030)
class UAudioWidgetSubsystem final : public UEngineSubsystem
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AudioWidgetSubsystem">();
	}
	static class UAudioWidgetSubsystem* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAudioWidgetSubsystem>();
	}
};
static_assert(alignof(UAudioWidgetSubsystem) == 0x000008, "Wrong alignment on UAudioWidgetSubsystem");
static_assert(sizeof(UAudioWidgetSubsystem) == 0x000030, "Wrong size on UAudioWidgetSubsystem");

// Class Engine.NavCollisionBase
// 0x0048 (0x0070 - 0x0028)
class UNavCollisionBase : public UObject
{
public:
	uint8                                         bIsDynamicObstacle : 1;                            // 0x0028(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, Config, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
	uint8                                         Pad_29[0x47];                                      // 0x0029(0x0047)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"NavCollisionBase">();
	}
	static class UNavCollisionBase* GetDefaultObj()
	{
		return GetDefaultObjImpl<UNavCollisionBase>();
	}
};
static_assert(alignof(UNavCollisionBase) == 0x000008, "Wrong alignment on UNavCollisionBase");
static_assert(sizeof(UNavCollisionBase) == 0x000070, "Wrong size on UNavCollisionBase");

// Class Engine.NavigationDataChunk
// 0x0008 (0x0030 - 0x0028)
class UNavigationDataChunk : public UObject
{
public:
	class FName                                   NavigationDataName;                                // 0x0028(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"NavigationDataChunk">();
	}
	static class UNavigationDataChunk* GetDefaultObj()
	{
		return GetDefaultObjImpl<UNavigationDataChunk>();
	}
};
static_assert(alignof(UNavigationDataChunk) == 0x000008, "Wrong alignment on UNavigationDataChunk");
static_assert(sizeof(UNavigationDataChunk) == 0x000030, "Wrong size on UNavigationDataChunk");
static_assert(offsetof(UNavigationDataChunk, NavigationDataName) == 0x000028, "Member 'UNavigationDataChunk::NavigationDataName' has a wrong offset!");

// Class Engine.AmbientSound
// 0x0008 (0x02A8 - 0x02A0)
class AAmbientSound final : public AActor
{
public:
	class UAudioComponent*                        AudioComponent;                                    // 0x02A0(0x0008)(Edit, BlueprintVisible, ExportObject, BlueprintReadOnly, ZeroConstructor, EditConst, InstancedReference, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)

public:
	void AdjustVolume(float AdjustVolumeDuration, float AdjustVolumeLevel);
	void FadeIn(float FadeInDuration, float FadeVolumeLevel);
	void FadeOut(float FadeOutDuration, float FadeVolumeLevel);
	void Play(float startTime);
	void Stop();

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AmbientSound">();
	}
	static class AAmbientSound* GetDefaultObj()
	{
		return GetDefaultObjImpl<AAmbientSound>();
	}
};
static_assert(alignof(AAmbientSound) == 0x000008, "Wrong alignment on AAmbientSound");
static_assert(sizeof(AAmbientSound) == 0x0002A8, "Wrong size on AAmbientSound");
static_assert(offsetof(AAmbientSound, AudioComponent) == 0x0002A0, "Member 'AAmbientSound::AudioComponent' has a wrong offset!");

// Class Engine.AimOffsetBlendSpace
// 0x0000 (0x01C0 - 0x01C0)
class UAimOffsetBlendSpace final : public UBlendSpace
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AimOffsetBlendSpace">();
	}
	static class UAimOffsetBlendSpace* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAimOffsetBlendSpace>();
	}
};
static_assert(alignof(UAimOffsetBlendSpace) == 0x000008, "Wrong alignment on UAimOffsetBlendSpace");
static_assert(sizeof(UAimOffsetBlendSpace) == 0x0001C0, "Wrong size on UAimOffsetBlendSpace");

// Class Engine.BlueprintMapLibrary
// 0x0000 (0x0028 - 0x0028)
class UBlueprintMapLibrary final : public UBlueprintFunctionLibrary
{
public:
	static void Map_Add(const TMap<int32, int32>& TargetMap, const int32& Key, const int32& Value);
	static void Map_Clear(const TMap<int32, int32>& TargetMap);
	static bool Map_Contains(const TMap<int32, int32>& TargetMap, const int32& Key);
	static bool Map_Find(const TMap<int32, int32>& TargetMap, const int32& Key, int32* Value);
	static bool Map_IsEmpty(const TMap<int32, int32>& TargetMap);
	static bool Map_IsNotEmpty(const TMap<int32, int32>& TargetMap);
	static void Map_Keys(const TMap<int32, int32>& TargetMap, TArray<int32>* Keys);
	static int32 Map_Length(const TMap<int32, int32>& TargetMap);
	static bool Map_Remove(const TMap<int32, int32>& TargetMap, const int32& Key);
	static void Map_Values(const TMap<int32, int32>& TargetMap, TArray<int32>* Values);
	static void SetMapPropertyByName(class UObject* Object, class FName PropertyName, const TMap<int32, int32>& Value);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"BlueprintMapLibrary">();
	}
	static class UBlueprintMapLibrary* GetDefaultObj()
	{
		return GetDefaultObjImpl<UBlueprintMapLibrary>();
	}
};
static_assert(alignof(UBlueprintMapLibrary) == 0x000008, "Wrong alignment on UBlueprintMapLibrary");
static_assert(sizeof(UBlueprintMapLibrary) == 0x000028, "Wrong size on UBlueprintMapLibrary");

// Class Engine.BlendSpace1D
// 0x0008 (0x01C8 - 0x01C0)
class UBlendSpace1D : public UBlendSpace
{
public:
	bool                                          bScaleAnimation;                                   // 0x01C0(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1C1[0x7];                                      // 0x01C1(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"BlendSpace1D">();
	}
	static class UBlendSpace1D* GetDefaultObj()
	{
		return GetDefaultObjImpl<UBlendSpace1D>();
	}
};
static_assert(alignof(UBlendSpace1D) == 0x000008, "Wrong alignment on UBlendSpace1D");
static_assert(sizeof(UBlendSpace1D) == 0x0001C8, "Wrong size on UBlendSpace1D");
static_assert(offsetof(UBlendSpace1D, bScaleAnimation) == 0x0001C0, "Member 'UBlendSpace1D::bScaleAnimation' has a wrong offset!");

// Class Engine.AimOffsetBlendSpace1D
// 0x0000 (0x01C8 - 0x01C8)
class UAimOffsetBlendSpace1D final : public UBlendSpace1D
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AimOffsetBlendSpace1D">();
	}
	static class UAimOffsetBlendSpace1D* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAimOffsetBlendSpace1D>();
	}
};
static_assert(alignof(UAimOffsetBlendSpace1D) == 0x000008, "Wrong alignment on UAimOffsetBlendSpace1D");
static_assert(sizeof(UAimOffsetBlendSpace1D) == 0x0001C8, "Wrong size on UAimOffsetBlendSpace1D");

// Class Engine.AnimationSettings
// 0x0110 (0x0148 - 0x0038)
class UAnimationSettings final : public UDeveloperSettings
{
public:
	int32                                         CompressCommandletVersion;                         // 0x0038(0x0004)(Edit, ZeroConstructor, Config, EditConst, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_3C[0x4];                                       // 0x003C(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<class FString>                         KeyEndEffectorsMatchNameArray;                     // 0x0040(0x0010)(Edit, ZeroConstructor, Config, NativeAccessSpecifierPublic)
	bool                                          ForceRecompression;                                // 0x0050(0x0001)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bForceBelowThreshold;                              // 0x0051(0x0001)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bFirstRecompressUsingCurrentOrDefault;             // 0x0052(0x0001)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bRaiseMaxErrorToExisting;                          // 0x0053(0x0001)(ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bEnablePerformanceLog;                             // 0x0054(0x0001)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bStripAnimationDataOnDedicatedServer;              // 0x0055(0x0001)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bTickAnimationOnSkeletalMeshInit;                  // 0x0056(0x0001)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_57[0x1];                                       // 0x0057(0x0001)(Fixing Size After Last Property [ Dumper-7 ])
	struct FTimecodeCustomAttributeNameSettings   BoneTimecodeCustomAttributeNameSettings;           // 0x0058(0x0038)(Edit, Config, NoDestructor, NativeAccessSpecifierPublic)
	TArray<struct FCustomAttributeSetting>        BoneCustomAttributesNames;                         // 0x0090(0x0010)(Edit, ZeroConstructor, Config, NativeAccessSpecifierPublic)
	TArray<class FString>                         BoneNamesWithCustomAttributes;                     // 0x00A0(0x0010)(Edit, ZeroConstructor, Config, NativeAccessSpecifierPublic)
	TMap<class FName, ECustomAttributeBlendType>  AttributeBlendModes;                               // 0x00B0(0x0050)(Edit, Config, NativeAccessSpecifierPublic)
	ECustomAttributeBlendType                     DefaultAttributeBlendMode;                         // 0x0100(0x0001)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_101[0x7];                                      // 0x0101(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<class FString>                         TransformAttributeNames;                           // 0x0108(0x0010)(Edit, ZeroConstructor, Config, NativeAccessSpecifierPublic)
	TArray<TSoftObjectPtr<class UUserDefinedStruct>> UserDefinedStructAttributes;                    // 0x0118(0x0010)(Edit, ZeroConstructor, Config, UObjectWrapper, NativeAccessSpecifierPublic)
	TArray<struct FMirrorFindReplaceExpression>   MirrorFindReplaceExpressions;                      // 0x0128(0x0010)(Edit, ZeroConstructor, Config, NativeAccessSpecifierPublic)
	struct FFrameRate                             DefaultFrameRate;                                  // 0x0138(0x0008)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bEnforceSupportedFrameRates;                       // 0x0140(0x0001)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_141[0x7];                                      // 0x0141(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	TArray<class FString> GetBoneCustomAttributeNamesToImport() const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AnimationSettings">();
	}
	static class UAnimationSettings* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAnimationSettings>();
	}
};
static_assert(alignof(UAnimationSettings) == 0x000008, "Wrong alignment on UAnimationSettings");
static_assert(sizeof(UAnimationSettings) == 0x000148, "Wrong size on UAnimationSettings");
static_assert(offsetof(UAnimationSettings, CompressCommandletVersion) == 0x000038, "Member 'UAnimationSettings::CompressCommandletVersion' has a wrong offset!");
static_assert(offsetof(UAnimationSettings, KeyEndEffectorsMatchNameArray) == 0x000040, "Member 'UAnimationSettings::KeyEndEffectorsMatchNameArray' has a wrong offset!");
static_assert(offsetof(UAnimationSettings, ForceRecompression) == 0x000050, "Member 'UAnimationSettings::ForceRecompression' has a wrong offset!");
static_assert(offsetof(UAnimationSettings, bForceBelowThreshold) == 0x000051, "Member 'UAnimationSettings::bForceBelowThreshold' has a wrong offset!");
static_assert(offsetof(UAnimationSettings, bFirstRecompressUsingCurrentOrDefault) == 0x000052, "Member 'UAnimationSettings::bFirstRecompressUsingCurrentOrDefault' has a wrong offset!");
static_assert(offsetof(UAnimationSettings, bRaiseMaxErrorToExisting) == 0x000053, "Member 'UAnimationSettings::bRaiseMaxErrorToExisting' has a wrong offset!");
static_assert(offsetof(UAnimationSettings, bEnablePerformanceLog) == 0x000054, "Member 'UAnimationSettings::bEnablePerformanceLog' has a wrong offset!");
static_assert(offsetof(UAnimationSettings, bStripAnimationDataOnDedicatedServer) == 0x000055, "Member 'UAnimationSettings::bStripAnimationDataOnDedicatedServer' has a wrong offset!");
static_assert(offsetof(UAnimationSettings, bTickAnimationOnSkeletalMeshInit) == 0x000056, "Member 'UAnimationSettings::bTickAnimationOnSkeletalMeshInit' has a wrong offset!");
static_assert(offsetof(UAnimationSettings, BoneTimecodeCustomAttributeNameSettings) == 0x000058, "Member 'UAnimationSettings::BoneTimecodeCustomAttributeNameSettings' has a wrong offset!");
static_assert(offsetof(UAnimationSettings, BoneCustomAttributesNames) == 0x000090, "Member 'UAnimationSettings::BoneCustomAttributesNames' has a wrong offset!");
static_assert(offsetof(UAnimationSettings, BoneNamesWithCustomAttributes) == 0x0000A0, "Member 'UAnimationSettings::BoneNamesWithCustomAttributes' has a wrong offset!");
static_assert(offsetof(UAnimationSettings, AttributeBlendModes) == 0x0000B0, "Member 'UAnimationSettings::AttributeBlendModes' has a wrong offset!");
static_assert(offsetof(UAnimationSettings, DefaultAttributeBlendMode) == 0x000100, "Member 'UAnimationSettings::DefaultAttributeBlendMode' has a wrong offset!");
static_assert(offsetof(UAnimationSettings, TransformAttributeNames) == 0x000108, "Member 'UAnimationSettings::TransformAttributeNames' has a wrong offset!");
static_assert(offsetof(UAnimationSettings, UserDefinedStructAttributes) == 0x000118, "Member 'UAnimationSettings::UserDefinedStructAttributes' has a wrong offset!");
static_assert(offsetof(UAnimationSettings, MirrorFindReplaceExpressions) == 0x000128, "Member 'UAnimationSettings::MirrorFindReplaceExpressions' has a wrong offset!");
static_assert(offsetof(UAnimationSettings, DefaultFrameRate) == 0x000138, "Member 'UAnimationSettings::DefaultFrameRate' has a wrong offset!");
static_assert(offsetof(UAnimationSettings, bEnforceSupportedFrameRates) == 0x000140, "Member 'UAnimationSettings::bEnforceSupportedFrameRates' has a wrong offset!");

// Class Engine.AnimBlueprintGeneratedStruct
// 0x0000 (0x00C0 - 0x00C0)
class UAnimBlueprintGeneratedStruct final : public UScriptStruct
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AnimBlueprintGeneratedStruct">();
	}
	static class UAnimBlueprintGeneratedStruct* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAnimBlueprintGeneratedStruct>();
	}
};
static_assert(alignof(UAnimBlueprintGeneratedStruct) == 0x000008, "Wrong alignment on UAnimBlueprintGeneratedStruct");
static_assert(sizeof(UAnimBlueprintGeneratedStruct) == 0x0000C0, "Wrong size on UAnimBlueprintGeneratedStruct");

// Class Engine.BrushShape
// 0x0000 (0x02D8 - 0x02D8)
class ABrushShape final : public ABrush
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"BrushShape">();
	}
	static class ABrushShape* GetDefaultObj()
	{
		return GetDefaultObjImpl<ABrushShape>();
	}
};
static_assert(alignof(ABrushShape) == 0x000008, "Wrong alignment on ABrushShape");
static_assert(sizeof(ABrushShape) == 0x0002D8, "Wrong size on ABrushShape");

// Class Engine.AnimBlueprintGeneratedClass
// 0x0268 (0x05D0 - 0x0368)
class UAnimBlueprintGeneratedClass final : public UBlueprintGeneratedClass
{
public:
	uint8                                         Pad_368[0x8];                                      // 0x0368(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<struct FBakedAnimationStateMachine>    BakedStateMachines;                                // 0x0370(0x0010)(ZeroConstructor, NativeAccessSpecifierPublic)
	class USkeleton*                              TargetSkeleton;                                    // 0x0380(0x0008)(ZeroConstructor, NoDestructor, AssetRegistrySearchable, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TArray<struct FAnimNotifyEvent>               AnimNotifies;                                      // 0x0388(0x0010)(ZeroConstructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
	TMap<class FName, struct FCachedPoseIndices>  OrderedSavedPoseIndicesMap;                        // 0x0398(0x0050)(NativeAccessSpecifierPublic)
	uint8                                         Pad_3E8[0x80];                                     // 0x03E8(0x0080)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<class FName>                           SyncGroupNames;                                    // 0x0468(0x0010)(ZeroConstructor, NativeAccessSpecifierPublic)
	TMap<class FName, struct FGraphAssetPlayerInformation> GraphAssetPlayerInformation;              // 0x0478(0x0050)(NativeAccessSpecifierPublic)
	TMap<class FName, struct FAnimGraphBlendOptions> GraphBlendOptions;                              // 0x04C8(0x0050)(NativeAccessSpecifierPublic)
	TArray<struct FAnimNodeData>                  AnimNodeData;                                      // 0x0518(0x0010)(ZeroConstructor, NativeAccessSpecifierPrivate)
	TMap<class UScriptStruct*, struct FAnimNodeStructData> NodeTypeMap;                              // 0x0528(0x0050)(NativeAccessSpecifierPrivate)
	uint8                                         Pad_578[0x58];                                     // 0x0578(0x0058)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AnimBlueprintGeneratedClass">();
	}
	static class UAnimBlueprintGeneratedClass* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAnimBlueprintGeneratedClass>();
	}
};
static_assert(alignof(UAnimBlueprintGeneratedClass) == 0x000008, "Wrong alignment on UAnimBlueprintGeneratedClass");
static_assert(sizeof(UAnimBlueprintGeneratedClass) == 0x0005D0, "Wrong size on UAnimBlueprintGeneratedClass");
static_assert(offsetof(UAnimBlueprintGeneratedClass, BakedStateMachines) == 0x000370, "Member 'UAnimBlueprintGeneratedClass::BakedStateMachines' has a wrong offset!");
static_assert(offsetof(UAnimBlueprintGeneratedClass, TargetSkeleton) == 0x000380, "Member 'UAnimBlueprintGeneratedClass::TargetSkeleton' has a wrong offset!");
static_assert(offsetof(UAnimBlueprintGeneratedClass, AnimNotifies) == 0x000388, "Member 'UAnimBlueprintGeneratedClass::AnimNotifies' has a wrong offset!");
static_assert(offsetof(UAnimBlueprintGeneratedClass, OrderedSavedPoseIndicesMap) == 0x000398, "Member 'UAnimBlueprintGeneratedClass::OrderedSavedPoseIndicesMap' has a wrong offset!");
static_assert(offsetof(UAnimBlueprintGeneratedClass, SyncGroupNames) == 0x000468, "Member 'UAnimBlueprintGeneratedClass::SyncGroupNames' has a wrong offset!");
static_assert(offsetof(UAnimBlueprintGeneratedClass, GraphAssetPlayerInformation) == 0x000478, "Member 'UAnimBlueprintGeneratedClass::GraphAssetPlayerInformation' has a wrong offset!");
static_assert(offsetof(UAnimBlueprintGeneratedClass, GraphBlendOptions) == 0x0004C8, "Member 'UAnimBlueprintGeneratedClass::GraphBlendOptions' has a wrong offset!");
static_assert(offsetof(UAnimBlueprintGeneratedClass, AnimNodeData) == 0x000518, "Member 'UAnimBlueprintGeneratedClass::AnimNodeData' has a wrong offset!");
static_assert(offsetof(UAnimBlueprintGeneratedClass, NodeTypeMap) == 0x000528, "Member 'UAnimBlueprintGeneratedClass::NodeTypeMap' has a wrong offset!");

// Class Engine.AnimBoneCompressionSettings
// 0x0010 (0x0038 - 0x0028)
class UAnimBoneCompressionSettings final : public UObject
{
public:
	TArray<class UAnimBoneCompressionCodec*>      Codecs;                                            // 0x0028(0x0010)(Edit, ExportObject, ZeroConstructor, ContainsInstancedReference, UObjectWrapper, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AnimBoneCompressionSettings">();
	}
	static class UAnimBoneCompressionSettings* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAnimBoneCompressionSettings>();
	}
};
static_assert(alignof(UAnimBoneCompressionSettings) == 0x000008, "Wrong alignment on UAnimBoneCompressionSettings");
static_assert(sizeof(UAnimBoneCompressionSettings) == 0x000038, "Wrong size on UAnimBoneCompressionSettings");
static_assert(offsetof(UAnimBoneCompressionSettings, Codecs) == 0x000028, "Member 'UAnimBoneCompressionSettings::Codecs' has a wrong offset!");

// Class Engine.AnimComposite
// 0x0010 (0x00C8 - 0x00B8)
class UAnimComposite final : public UAnimCompositeBase
{
public:
	struct FAnimTrack                             AnimationTrack;                                    // 0x00B8(0x0010)(NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AnimComposite">();
	}
	static class UAnimComposite* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAnimComposite>();
	}
};
static_assert(alignof(UAnimComposite) == 0x000008, "Wrong alignment on UAnimComposite");
static_assert(sizeof(UAnimComposite) == 0x0000C8, "Wrong size on UAnimComposite");
static_assert(offsetof(UAnimComposite, AnimationTrack) == 0x0000B8, "Member 'UAnimComposite::AnimationTrack' has a wrong offset!");

// Class Engine.AnimCurveCompressionSettings
// 0x0008 (0x0030 - 0x0028)
class UAnimCurveCompressionSettings final : public UObject
{
public:
	class UAnimCurveCompressionCodec*             Codec;                                             // 0x0028(0x0008)(Edit, ExportObject, ZeroConstructor, NoClear, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AnimCurveCompressionSettings">();
	}
	static class UAnimCurveCompressionSettings* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAnimCurveCompressionSettings>();
	}
};
static_assert(alignof(UAnimCurveCompressionSettings) == 0x000008, "Wrong alignment on UAnimCurveCompressionSettings");
static_assert(sizeof(UAnimCurveCompressionSettings) == 0x000030, "Wrong size on UAnimCurveCompressionSettings");
static_assert(offsetof(UAnimCurveCompressionSettings, Codec) == 0x000028, "Member 'UAnimCurveCompressionSettings::Codec' has a wrong offset!");

// Class Engine.AnimNotifyLibrary
// 0x0000 (0x0028 - 0x0028)
class UAnimNotifyLibrary final : public UBlueprintFunctionLibrary
{
public:
	static float GetCurrentAnimationNotifyStateTime(const struct FAnimNotifyEventReference& EventReference);
	static float GetCurrentAnimationNotifyStateTimeRatio(const struct FAnimNotifyEventReference& EventReference);
	static float GetCurrentAnimationTime(const struct FAnimNotifyEventReference& EventReference);
	static float GetCurrentAnimationTimeRatio(const struct FAnimNotifyEventReference& EventReference);
	static bool NotifyStateReachedEnd(const struct FAnimNotifyEventReference& EventReference);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AnimNotifyLibrary">();
	}
	static class UAnimNotifyLibrary* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAnimNotifyLibrary>();
	}
};
static_assert(alignof(UAnimNotifyLibrary) == 0x000008, "Wrong alignment on UAnimNotifyLibrary");
static_assert(sizeof(UAnimNotifyLibrary) == 0x000028, "Wrong size on UAnimNotifyLibrary");

// Class Engine.AnimNotifyState_TimedParticleEffect
// 0x0048 (0x0078 - 0x0030)
class UAnimNotifyState_TimedParticleEffect final : public UAnimNotifyState
{
public:
	class UParticleSystem*                        PSTemplate;                                        // 0x0030(0x0008)(Edit, BlueprintReadOnly, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FName                                   SocketName;                                        // 0x0038(0x0008)(Edit, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector                                LocationOffset;                                    // 0x0040(0x0018)(Edit, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FRotator                               RotationOffset;                                    // 0x0058(0x0018)(Edit, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
	bool                                          bDestroyAtEnd;                                     // 0x0070(0x0001)(Edit, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_71[0x7];                                       // 0x0071(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AnimNotifyState_TimedParticleEffect">();
	}
	static class UAnimNotifyState_TimedParticleEffect* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAnimNotifyState_TimedParticleEffect>();
	}
};
static_assert(alignof(UAnimNotifyState_TimedParticleEffect) == 0x000008, "Wrong alignment on UAnimNotifyState_TimedParticleEffect");
static_assert(sizeof(UAnimNotifyState_TimedParticleEffect) == 0x000078, "Wrong size on UAnimNotifyState_TimedParticleEffect");
static_assert(offsetof(UAnimNotifyState_TimedParticleEffect, PSTemplate) == 0x000030, "Member 'UAnimNotifyState_TimedParticleEffect::PSTemplate' has a wrong offset!");
static_assert(offsetof(UAnimNotifyState_TimedParticleEffect, SocketName) == 0x000038, "Member 'UAnimNotifyState_TimedParticleEffect::SocketName' has a wrong offset!");
static_assert(offsetof(UAnimNotifyState_TimedParticleEffect, LocationOffset) == 0x000040, "Member 'UAnimNotifyState_TimedParticleEffect::LocationOffset' has a wrong offset!");
static_assert(offsetof(UAnimNotifyState_TimedParticleEffect, RotationOffset) == 0x000058, "Member 'UAnimNotifyState_TimedParticleEffect::RotationOffset' has a wrong offset!");
static_assert(offsetof(UAnimNotifyState_TimedParticleEffect, bDestroyAtEnd) == 0x000070, "Member 'UAnimNotifyState_TimedParticleEffect::bDestroyAtEnd' has a wrong offset!");

// Class Engine.AnimNotify_PlaySound
// 0x0020 (0x0058 - 0x0038)
class UAnimNotify_PlaySound final : public UAnimNotify
{
public:
	class USoundBase*                             Sound;                                             // 0x0038(0x0008)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, NoDestructor, ExposeOnSpawn, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         VolumeMultiplier;                                  // 0x0040(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, ExposeOnSpawn, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         PitchMultiplier;                                   // 0x0044(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, ExposeOnSpawn, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bFollow : 1;                                       // 0x0048(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_49[0x3];                                       // 0x0049(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	class FName                                   AttachName;                                        // 0x004C(0x0008)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, ExposeOnSpawn, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_54[0x4];                                       // 0x0054(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AnimNotify_PlaySound">();
	}
	static class UAnimNotify_PlaySound* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAnimNotify_PlaySound>();
	}
};
static_assert(alignof(UAnimNotify_PlaySound) == 0x000008, "Wrong alignment on UAnimNotify_PlaySound");
static_assert(sizeof(UAnimNotify_PlaySound) == 0x000058, "Wrong size on UAnimNotify_PlaySound");
static_assert(offsetof(UAnimNotify_PlaySound, Sound) == 0x000038, "Member 'UAnimNotify_PlaySound::Sound' has a wrong offset!");
static_assert(offsetof(UAnimNotify_PlaySound, VolumeMultiplier) == 0x000040, "Member 'UAnimNotify_PlaySound::VolumeMultiplier' has a wrong offset!");
static_assert(offsetof(UAnimNotify_PlaySound, PitchMultiplier) == 0x000044, "Member 'UAnimNotify_PlaySound::PitchMultiplier' has a wrong offset!");
static_assert(offsetof(UAnimNotify_PlaySound, AttachName) == 0x00004C, "Member 'UAnimNotify_PlaySound::AttachName' has a wrong offset!");

// Class Engine.AnimSequence
// 0x0148 (0x01F8 - 0x00B0)
class UAnimSequence final : public UAnimSequenceBase
{
public:
	class UAnimBoneCompressionSettings*           BoneCompressionSettings;                           // 0x00B0(0x0008)(Edit, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UAnimCurveCompressionSettings*          CurveCompressionSettings;                          // 0x00B8(0x0008)(Edit, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_C0[0x80];                                      // 0x00C0(0x0080)(Fixing Size After Last Property [ Dumper-7 ])
	class UVariableFrameStrippingSettings*        VariableFrameStrippingSettings;                    // 0x0140(0x0008)(Edit, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EAdditiveAnimationType                        AdditiveAnimType;                                  // 0x0148(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, AssetRegistrySearchable, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EAdditiveBasePoseType                         RefPoseType;                                       // 0x0149(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_14A[0x2];                                      // 0x014A(0x0002)(Fixing Size After Last Property [ Dumper-7 ])
	int32                                         RefFrameIndex;                                     // 0x014C(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UAnimSequence*                          RefPoseSeq;                                        // 0x0150(0x0008)(Edit, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FName                                   RetargetSource;                                    // 0x0158(0x0008)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, AssetRegistrySearchable, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TArray<struct FTransform>                     RetargetSourceAssetReferencePose;                  // 0x0160(0x0010)(ZeroConstructor, NativeAccessSpecifierPublic)
	EAnimInterpolationType                        Interpolation;                                     // 0x0170(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, AssetRegistrySearchable, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bEnableRootMotion;                                 // 0x0171(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, AssetRegistrySearchable, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	ERootMotionRootLock                           RootMotionRootLock;                                // 0x0172(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bForceRootLock;                                    // 0x0173(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bUseNormalizedRootMotionScale;                     // 0x0174(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, AssetRegistrySearchable, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bRootMotionSettingsCopiedFromMontage;              // 0x0175(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_176[0x2];                                      // 0x0176(0x0002)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<struct FAnimSyncMarker>                AuthoredSyncMarkers;                               // 0x0178(0x0010)(ZeroConstructor, NativeAccessSpecifierPublic)
	uint8                                         Pad_188[0x10];                                     // 0x0188(0x0010)(Fixing Size After Last Property [ Dumper-7 ])
	struct FFrameRate                             TargetFrameRate;                                   // 0x0198(0x0008)(Edit, ZeroConstructor, EditConst, IsPlainOldData, NoDestructor, AssetRegistrySearchable, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	struct FPerPlatformFrameRate                  PlatformTargetFrameRate;                           // 0x01A0(0x0008)(Edit, EditConst, NoDestructor, AssetRegistrySearchable, Protected, NativeAccessSpecifierProtected)
	TMap<struct FAnimationAttributeIdentifier, struct FAttributeCurve> AttributeCurves;              // 0x01A8(0x0050)(Protected, NativeAccessSpecifierProtected)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AnimSequence">();
	}
	static class UAnimSequence* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAnimSequence>();
	}
};
static_assert(alignof(UAnimSequence) == 0x000008, "Wrong alignment on UAnimSequence");
static_assert(sizeof(UAnimSequence) == 0x0001F8, "Wrong size on UAnimSequence");
static_assert(offsetof(UAnimSequence, BoneCompressionSettings) == 0x0000B0, "Member 'UAnimSequence::BoneCompressionSettings' has a wrong offset!");
static_assert(offsetof(UAnimSequence, CurveCompressionSettings) == 0x0000B8, "Member 'UAnimSequence::CurveCompressionSettings' has a wrong offset!");
static_assert(offsetof(UAnimSequence, VariableFrameStrippingSettings) == 0x000140, "Member 'UAnimSequence::VariableFrameStrippingSettings' has a wrong offset!");
static_assert(offsetof(UAnimSequence, AdditiveAnimType) == 0x000148, "Member 'UAnimSequence::AdditiveAnimType' has a wrong offset!");
static_assert(offsetof(UAnimSequence, RefPoseType) == 0x000149, "Member 'UAnimSequence::RefPoseType' has a wrong offset!");
static_assert(offsetof(UAnimSequence, RefFrameIndex) == 0x00014C, "Member 'UAnimSequence::RefFrameIndex' has a wrong offset!");
static_assert(offsetof(UAnimSequence, RefPoseSeq) == 0x000150, "Member 'UAnimSequence::RefPoseSeq' has a wrong offset!");
static_assert(offsetof(UAnimSequence, RetargetSource) == 0x000158, "Member 'UAnimSequence::RetargetSource' has a wrong offset!");
static_assert(offsetof(UAnimSequence, RetargetSourceAssetReferencePose) == 0x000160, "Member 'UAnimSequence::RetargetSourceAssetReferencePose' has a wrong offset!");
static_assert(offsetof(UAnimSequence, Interpolation) == 0x000170, "Member 'UAnimSequence::Interpolation' has a wrong offset!");
static_assert(offsetof(UAnimSequence, bEnableRootMotion) == 0x000171, "Member 'UAnimSequence::bEnableRootMotion' has a wrong offset!");
static_assert(offsetof(UAnimSequence, RootMotionRootLock) == 0x000172, "Member 'UAnimSequence::RootMotionRootLock' has a wrong offset!");
static_assert(offsetof(UAnimSequence, bForceRootLock) == 0x000173, "Member 'UAnimSequence::bForceRootLock' has a wrong offset!");
static_assert(offsetof(UAnimSequence, bUseNormalizedRootMotionScale) == 0x000174, "Member 'UAnimSequence::bUseNormalizedRootMotionScale' has a wrong offset!");
static_assert(offsetof(UAnimSequence, bRootMotionSettingsCopiedFromMontage) == 0x000175, "Member 'UAnimSequence::bRootMotionSettingsCopiedFromMontage' has a wrong offset!");
static_assert(offsetof(UAnimSequence, AuthoredSyncMarkers) == 0x000178, "Member 'UAnimSequence::AuthoredSyncMarkers' has a wrong offset!");
static_assert(offsetof(UAnimSequence, TargetFrameRate) == 0x000198, "Member 'UAnimSequence::TargetFrameRate' has a wrong offset!");
static_assert(offsetof(UAnimSequence, PlatformTargetFrameRate) == 0x0001A0, "Member 'UAnimSequence::PlatformTargetFrameRate' has a wrong offset!");
static_assert(offsetof(UAnimSequence, AttributeCurves) == 0x0001A8, "Member 'UAnimSequence::AttributeCurves' has a wrong offset!");

// Class Engine.AnimStreamable
// 0x0048 (0x00F8 - 0x00B0)
class UAnimStreamable final : public UAnimSequenceBase
{
public:
	int32                                         NumberOfKeys;                                      // 0x00B0(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, AssetRegistrySearchable, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EAnimInterpolationType                        Interpolation;                                     // 0x00B4(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, AssetRegistrySearchable, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_B5[0x3];                                       // 0x00B5(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	class FName                                   RetargetSource;                                    // 0x00B8(0x0008)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, AssetRegistrySearchable, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FFrameRate                             SamplingFrameRate;                                 // 0x00C0(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_C8[0x10];                                      // 0x00C8(0x0010)(Fixing Size After Last Property [ Dumper-7 ])
	class UAnimBoneCompressionSettings*           BoneCompressionSettings;                           // 0x00D8(0x0008)(Edit, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UAnimCurveCompressionSettings*          CurveCompressionSettings;                          // 0x00E0(0x0008)(Edit, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UVariableFrameStrippingSettings*        VariableFrameStrippingSettings;                    // 0x00E8(0x0008)(Edit, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bEnableRootMotion;                                 // 0x00F0(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, AssetRegistrySearchable, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	ERootMotionRootLock                           RootMotionRootLock;                                // 0x00F1(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bForceRootLock;                                    // 0x00F2(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bUseNormalizedRootMotionScale;                     // 0x00F3(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, AssetRegistrySearchable, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_F4[0x4];                                       // 0x00F4(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AnimStreamable">();
	}
	static class UAnimStreamable* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAnimStreamable>();
	}
};
static_assert(alignof(UAnimStreamable) == 0x000008, "Wrong alignment on UAnimStreamable");
static_assert(sizeof(UAnimStreamable) == 0x0000F8, "Wrong size on UAnimStreamable");
static_assert(offsetof(UAnimStreamable, NumberOfKeys) == 0x0000B0, "Member 'UAnimStreamable::NumberOfKeys' has a wrong offset!");
static_assert(offsetof(UAnimStreamable, Interpolation) == 0x0000B4, "Member 'UAnimStreamable::Interpolation' has a wrong offset!");
static_assert(offsetof(UAnimStreamable, RetargetSource) == 0x0000B8, "Member 'UAnimStreamable::RetargetSource' has a wrong offset!");
static_assert(offsetof(UAnimStreamable, SamplingFrameRate) == 0x0000C0, "Member 'UAnimStreamable::SamplingFrameRate' has a wrong offset!");
static_assert(offsetof(UAnimStreamable, BoneCompressionSettings) == 0x0000D8, "Member 'UAnimStreamable::BoneCompressionSettings' has a wrong offset!");
static_assert(offsetof(UAnimStreamable, CurveCompressionSettings) == 0x0000E0, "Member 'UAnimStreamable::CurveCompressionSettings' has a wrong offset!");
static_assert(offsetof(UAnimStreamable, VariableFrameStrippingSettings) == 0x0000E8, "Member 'UAnimStreamable::VariableFrameStrippingSettings' has a wrong offset!");
static_assert(offsetof(UAnimStreamable, bEnableRootMotion) == 0x0000F0, "Member 'UAnimStreamable::bEnableRootMotion' has a wrong offset!");
static_assert(offsetof(UAnimStreamable, RootMotionRootLock) == 0x0000F1, "Member 'UAnimStreamable::RootMotionRootLock' has a wrong offset!");
static_assert(offsetof(UAnimStreamable, bForceRootLock) == 0x0000F2, "Member 'UAnimStreamable::bForceRootLock' has a wrong offset!");
static_assert(offsetof(UAnimStreamable, bUseNormalizedRootMotionScale) == 0x0000F3, "Member 'UAnimStreamable::bUseNormalizedRootMotionScale' has a wrong offset!");

// Class Engine.AssetMappingTable
// 0x0010 (0x0038 - 0x0028)
class UAssetMappingTable final : public UObject
{
public:
	TArray<struct FAssetMapping>                  MappedAssets;                                      // 0x0028(0x0010)(Edit, EditFixedSize, ZeroConstructor, EditConst, NativeAccessSpecifierPrivate)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AssetMappingTable">();
	}
	static class UAssetMappingTable* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAssetMappingTable>();
	}
};
static_assert(alignof(UAssetMappingTable) == 0x000008, "Wrong alignment on UAssetMappingTable");
static_assert(sizeof(UAssetMappingTable) == 0x000038, "Wrong size on UAssetMappingTable");
static_assert(offsetof(UAssetMappingTable, MappedAssets) == 0x000028, "Member 'UAssetMappingTable::MappedAssets' has a wrong offset!");

// Class Engine.Skeleton
// 0x03D8 (0x0400 - 0x0028)
class USkeleton final : public UObject
{
public:
	uint8                                         Pad_28[0x10];                                      // 0x0028(0x0010)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<struct FBoneNode>                      BoneTree;                                          // 0x0038(0x0010)(Edit, ZeroConstructor, EditConst, Protected, NativeAccessSpecifierProtected)
	uint8                                         Pad_48[0x118];                                     // 0x0048(0x0118)(Fixing Size After Last Property [ Dumper-7 ])
	struct FGuid                                  VirtualBoneGuid;                                   // 0x0160(0x0010)(ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	TArray<struct FVirtualBone>                   VirtualBones;                                      // 0x0170(0x0010)(ZeroConstructor, Protected, NativeAccessSpecifierProtected)
	TArray<TSoftObjectPtr<class USkeleton>>       CompatibleSkeletons;                               // 0x0180(0x0010)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, Protected, UObjectWrapper, NativeAccessSpecifierProtected)
	TArray<class USkeletalMeshSocket*>            Sockets;                                           // 0x0190(0x0010)(ZeroConstructor, UObjectWrapper, NativeAccessSpecifierPublic)
	uint8                                         Pad_1A0[0x50];                                     // 0x01A0(0x0050)(Fixing Size After Last Property [ Dumper-7 ])
	struct FSmartNameContainer                    SmartNames;                                        // 0x01F0(0x0050)(Deprecated, Protected, NativeAccessSpecifierProtected)
	uint8                                         Pad_240[0x10];                                     // 0x0240(0x0010)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<class UBlendProfile*>                  BlendProfiles;                                     // 0x0250(0x0010)(ExportObject, ZeroConstructor, ContainsInstancedReference, UObjectWrapper, NativeAccessSpecifierPublic)
	TArray<struct FAnimSlotGroup>                 SlotGroups;                                        // 0x0260(0x0010)(ZeroConstructor, NativeAccessSpecifierPrivate)
	uint8                                         Pad_270[0x180];                                    // 0x0270(0x0180)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<class UAssetUserData*>                 AssetUserData;                                     // 0x03F0(0x0010)(Edit, ExportObject, ZeroConstructor, ContainsInstancedReference, AdvancedDisplay, Protected, UObjectWrapper, NativeAccessSpecifierProtected)

public:
	void AddCompatibleSkeleton(const class USkeleton* SourceSkeleton);
	void AddCompatibleSkeletonSoft(const TSoftObjectPtr<class USkeleton>& SourceSkeleton);
	class UBlendProfile* GetBlendProfile(const class FName& InProfileName);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"Skeleton">();
	}
	static class USkeleton* GetDefaultObj()
	{
		return GetDefaultObjImpl<USkeleton>();
	}
};
static_assert(alignof(USkeleton) == 0x000008, "Wrong alignment on USkeleton");
static_assert(sizeof(USkeleton) == 0x000400, "Wrong size on USkeleton");
static_assert(offsetof(USkeleton, BoneTree) == 0x000038, "Member 'USkeleton::BoneTree' has a wrong offset!");
static_assert(offsetof(USkeleton, VirtualBoneGuid) == 0x000160, "Member 'USkeleton::VirtualBoneGuid' has a wrong offset!");
static_assert(offsetof(USkeleton, VirtualBones) == 0x000170, "Member 'USkeleton::VirtualBones' has a wrong offset!");
static_assert(offsetof(USkeleton, CompatibleSkeletons) == 0x000180, "Member 'USkeleton::CompatibleSkeletons' has a wrong offset!");
static_assert(offsetof(USkeleton, Sockets) == 0x000190, "Member 'USkeleton::Sockets' has a wrong offset!");
static_assert(offsetof(USkeleton, SmartNames) == 0x0001F0, "Member 'USkeleton::SmartNames' has a wrong offset!");
static_assert(offsetof(USkeleton, BlendProfiles) == 0x000250, "Member 'USkeleton::BlendProfiles' has a wrong offset!");
static_assert(offsetof(USkeleton, SlotGroups) == 0x000260, "Member 'USkeleton::SlotGroups' has a wrong offset!");
static_assert(offsetof(USkeleton, AssetUserData) == 0x0003F0, "Member 'USkeleton::AssetUserData' has a wrong offset!");

// Class Engine.BlendProfile
// 0x0028 (0x0050 - 0x0028)
class UBlendProfile final : public UObject
{
public:
	uint8                                         Pad_28[0x8];                                       // 0x0028(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	class USkeleton*                              OwningSkeleton;                                    // 0x0030(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TArray<struct FBlendProfileBoneEntry>         ProfileEntries;                                    // 0x0038(0x0010)(ZeroConstructor, NativeAccessSpecifierPublic)
	EBlendProfileMode                             Mode;                                              // 0x0048(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_49[0x7];                                       // 0x0049(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"BlendProfile">();
	}
	static class UBlendProfile* GetDefaultObj()
	{
		return GetDefaultObjImpl<UBlendProfile>();
	}
};
static_assert(alignof(UBlendProfile) == 0x000008, "Wrong alignment on UBlendProfile");
static_assert(sizeof(UBlendProfile) == 0x000050, "Wrong size on UBlendProfile");
static_assert(offsetof(UBlendProfile, OwningSkeleton) == 0x000030, "Member 'UBlendProfile::OwningSkeleton' has a wrong offset!");
static_assert(offsetof(UBlendProfile, ProfileEntries) == 0x000038, "Member 'UBlendProfile::ProfileEntries' has a wrong offset!");
static_assert(offsetof(UBlendProfile, Mode) == 0x000048, "Member 'UBlendProfile::Mode' has a wrong offset!");

// Class Engine.CurveSourceInterface
// 0x0000 (0x0000 - 0x0000)
class ICurveSourceInterface final
{
public:
	class FName GetBindingName() const;
	void GetCurves(TArray<struct FNamedCurveValue>* OutValues) const;
	float GetCurveValue(class FName CurveName) const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"CurveSourceInterface">();
	}
	static class ICurveSourceInterface* GetDefaultObj()
	{
		return GetDefaultObjImpl<ICurveSourceInterface>();
	}

	class UObject* AsUObject()
	{
		return reinterpret_cast<UObject*>(this);
	}
	const class UObject* AsUObject() const
	{
		return reinterpret_cast<const UObject*>(this);
	}
};
static_assert(alignof(ICurveSourceInterface) == 0x000001, "Wrong alignment on ICurveSourceInterface");
static_assert(sizeof(ICurveSourceInterface) == 0x000001, "Wrong size on ICurveSourceInterface");

// Class Engine.NodeMappingContainer
// 0x0140 (0x0168 - 0x0028)
class UNodeMappingContainer final : public UObject
{
public:
	TMap<class FName, struct FNodeItem>           SourceItems;                                       // 0x0028(0x0050)(Edit, EditConst, NativeAccessSpecifierPrivate)
	TMap<class FName, struct FNodeItem>           TargetItems;                                       // 0x0078(0x0050)(Edit, EditConst, NativeAccessSpecifierPrivate)
	TMap<class FName, class FName>                SourceToTarget;                                    // 0x00C8(0x0050)(Edit, NativeAccessSpecifierPrivate)
	TSoftObjectPtr<class UObject>                 SourceAsset;                                       // 0x0118(0x0028)(Edit, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	TSoftObjectPtr<class UObject>                 TargetAsset;                                       // 0x0140(0x0028)(Edit, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"NodeMappingContainer">();
	}
	static class UNodeMappingContainer* GetDefaultObj()
	{
		return GetDefaultObjImpl<UNodeMappingContainer>();
	}
};
static_assert(alignof(UNodeMappingContainer) == 0x000008, "Wrong alignment on UNodeMappingContainer");
static_assert(sizeof(UNodeMappingContainer) == 0x000168, "Wrong size on UNodeMappingContainer");
static_assert(offsetof(UNodeMappingContainer, SourceItems) == 0x000028, "Member 'UNodeMappingContainer::SourceItems' has a wrong offset!");
static_assert(offsetof(UNodeMappingContainer, TargetItems) == 0x000078, "Member 'UNodeMappingContainer::TargetItems' has a wrong offset!");
static_assert(offsetof(UNodeMappingContainer, SourceToTarget) == 0x0000C8, "Member 'UNodeMappingContainer::SourceToTarget' has a wrong offset!");
static_assert(offsetof(UNodeMappingContainer, SourceAsset) == 0x000118, "Member 'UNodeMappingContainer::SourceAsset' has a wrong offset!");
static_assert(offsetof(UNodeMappingContainer, TargetAsset) == 0x000140, "Member 'UNodeMappingContainer::TargetAsset' has a wrong offset!");

// Class Engine.NodeMappingProviderInterface
// 0x0000 (0x0000 - 0x0000)
class INodeMappingProviderInterface final
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"NodeMappingProviderInterface">();
	}
	static class INodeMappingProviderInterface* GetDefaultObj()
	{
		return GetDefaultObjImpl<INodeMappingProviderInterface>();
	}

	class UObject* AsUObject()
	{
		return reinterpret_cast<UObject*>(this);
	}
	const class UObject* AsUObject() const
	{
		return reinterpret_cast<const UObject*>(this);
	}
};
static_assert(alignof(INodeMappingProviderInterface) == 0x000001, "Wrong alignment on INodeMappingProviderInterface");
static_assert(sizeof(INodeMappingProviderInterface) == 0x000001, "Wrong size on INodeMappingProviderInterface");

// Class Engine.PreviewMeshCollection
// 0x0020 (0x0050 - 0x0030)
class UPreviewMeshCollection final : public UDataAsset
{
public:
	uint8                                         Pad_30[0x8];                                       // 0x0030(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	class USkeleton*                              Skeleton;                                          // 0x0038(0x0008)(Edit, ZeroConstructor, EditConst, NoDestructor, AssetRegistrySearchable, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TArray<struct FPreviewMeshCollectionEntry>    SkeletalMeshes;                                    // 0x0040(0x0010)(Edit, ZeroConstructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"PreviewMeshCollection">();
	}
	static class UPreviewMeshCollection* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPreviewMeshCollection>();
	}
};
static_assert(alignof(UPreviewMeshCollection) == 0x000008, "Wrong alignment on UPreviewMeshCollection");
static_assert(sizeof(UPreviewMeshCollection) == 0x000050, "Wrong size on UPreviewMeshCollection");
static_assert(offsetof(UPreviewMeshCollection, Skeleton) == 0x000038, "Member 'UPreviewMeshCollection::Skeleton' has a wrong offset!");
static_assert(offsetof(UPreviewMeshCollection, SkeletalMeshes) == 0x000040, "Member 'UPreviewMeshCollection::SkeletalMeshes' has a wrong offset!");

// Class Engine.AssetManager
// 0x04A8 (0x04D0 - 0x0028)
class UAssetManager : public UObject
{
public:
	uint8                                         Pad_28[0x308];                                     // 0x0028(0x0308)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<class UObject*>                        ObjectReferenceList;                               // 0x0330(0x0010)(ZeroConstructor, Protected, UObjectWrapper, NativeAccessSpecifierProtected)
	bool                                          bIsGlobalAsyncScanEnvironment;                     // 0x0340(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	bool                                          bShouldGuessTypeAndName;                           // 0x0341(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	bool                                          bShouldUseSynchronousLoad;                         // 0x0342(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	bool                                          bIsLoadingFromPakFiles;                            // 0x0343(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	bool                                          bShouldAcquireMissingChunksOnLoad;                 // 0x0344(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	bool                                          bOnlyCookProductionAssets;                         // 0x0345(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_346[0x2];                                      // 0x0346(0x0002)(Fixing Size After Last Property [ Dumper-7 ])
	int32                                         NumBulkScanRequests;                               // 0x0348(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	bool                                          bIsPrimaryAssetDirectoryCurrent;                   // 0x034C(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	bool                                          bIsManagementDatabaseCurrent;                      // 0x034D(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	bool                                          bUpdateManagementDatabaseAfterScan;                // 0x034E(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	bool                                          bIncludeOnlyOnDiskAssets;                          // 0x034F(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	bool                                          bHasCompletedInitialScan;                          // 0x0350(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_351[0x3];                                      // 0x0351(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	int32                                         NumberOfSpawnedNotifications;                      // 0x0354(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_358[0x178];                                    // 0x0358(0x0178)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AssetManager">();
	}
	static class UAssetManager* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAssetManager>();
	}
};
static_assert(alignof(UAssetManager) == 0x000008, "Wrong alignment on UAssetManager");
static_assert(sizeof(UAssetManager) == 0x0004D0, "Wrong size on UAssetManager");
static_assert(offsetof(UAssetManager, ObjectReferenceList) == 0x000330, "Member 'UAssetManager::ObjectReferenceList' has a wrong offset!");
static_assert(offsetof(UAssetManager, bIsGlobalAsyncScanEnvironment) == 0x000340, "Member 'UAssetManager::bIsGlobalAsyncScanEnvironment' has a wrong offset!");
static_assert(offsetof(UAssetManager, bShouldGuessTypeAndName) == 0x000341, "Member 'UAssetManager::bShouldGuessTypeAndName' has a wrong offset!");
static_assert(offsetof(UAssetManager, bShouldUseSynchronousLoad) == 0x000342, "Member 'UAssetManager::bShouldUseSynchronousLoad' has a wrong offset!");
static_assert(offsetof(UAssetManager, bIsLoadingFromPakFiles) == 0x000343, "Member 'UAssetManager::bIsLoadingFromPakFiles' has a wrong offset!");
static_assert(offsetof(UAssetManager, bShouldAcquireMissingChunksOnLoad) == 0x000344, "Member 'UAssetManager::bShouldAcquireMissingChunksOnLoad' has a wrong offset!");
static_assert(offsetof(UAssetManager, bOnlyCookProductionAssets) == 0x000345, "Member 'UAssetManager::bOnlyCookProductionAssets' has a wrong offset!");
static_assert(offsetof(UAssetManager, NumBulkScanRequests) == 0x000348, "Member 'UAssetManager::NumBulkScanRequests' has a wrong offset!");
static_assert(offsetof(UAssetManager, bIsPrimaryAssetDirectoryCurrent) == 0x00034C, "Member 'UAssetManager::bIsPrimaryAssetDirectoryCurrent' has a wrong offset!");
static_assert(offsetof(UAssetManager, bIsManagementDatabaseCurrent) == 0x00034D, "Member 'UAssetManager::bIsManagementDatabaseCurrent' has a wrong offset!");
static_assert(offsetof(UAssetManager, bUpdateManagementDatabaseAfterScan) == 0x00034E, "Member 'UAssetManager::bUpdateManagementDatabaseAfterScan' has a wrong offset!");
static_assert(offsetof(UAssetManager, bIncludeOnlyOnDiskAssets) == 0x00034F, "Member 'UAssetManager::bIncludeOnlyOnDiskAssets' has a wrong offset!");
static_assert(offsetof(UAssetManager, bHasCompletedInitialScan) == 0x000350, "Member 'UAssetManager::bHasCompletedInitialScan' has a wrong offset!");
static_assert(offsetof(UAssetManager, NumberOfSpawnedNotifications) == 0x000354, "Member 'UAssetManager::NumberOfSpawnedNotifications' has a wrong offset!");

// Class Engine.AsyncActionLoadPrimaryAssetList
// 0x0010 (0x0088 - 0x0078)
class UAsyncActionLoadPrimaryAssetList final : public UAsyncActionLoadPrimaryAssetBase
{
public:
	TMulticastInlineDelegate<void(const TArray<class UObject*>& Loaded)> Completed;                  // 0x0078(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)

public:
	static class UAsyncActionLoadPrimaryAssetList* AsyncLoadPrimaryAssetList(class UObject* WorldContextObject, const TArray<struct FPrimaryAssetId>& PrimaryAssetList, const TArray<class FName>& LoadBundles);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AsyncActionLoadPrimaryAssetList">();
	}
	static class UAsyncActionLoadPrimaryAssetList* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAsyncActionLoadPrimaryAssetList>();
	}
};
static_assert(alignof(UAsyncActionLoadPrimaryAssetList) == 0x000008, "Wrong alignment on UAsyncActionLoadPrimaryAssetList");
static_assert(sizeof(UAsyncActionLoadPrimaryAssetList) == 0x000088, "Wrong size on UAsyncActionLoadPrimaryAssetList");
static_assert(offsetof(UAsyncActionLoadPrimaryAssetList, Completed) == 0x000078, "Member 'UAsyncActionLoadPrimaryAssetList::Completed' has a wrong offset!");

// Class Engine.AudioSettings
// 0x01B0 (0x01E8 - 0x0038)
class UAudioSettings final : public UDeveloperSettings
{
public:
	struct FSoftObjectPath                        DefaultSoundClassName;                             // 0x0038(0x0020)(Edit, ZeroConstructor, Config, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FSoftObjectPath                        DefaultMediaSoundClassName;                        // 0x0058(0x0020)(Edit, ZeroConstructor, Config, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FSoftObjectPath                        DefaultSoundConcurrencyName;                       // 0x0078(0x0020)(Edit, ZeroConstructor, Config, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FSoftObjectPath                        DefaultBaseSoundMix;                               // 0x0098(0x0020)(Edit, ZeroConstructor, Config, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FSoftObjectPath                        VoiPSoundClass;                                    // 0x00B8(0x0020)(Edit, ZeroConstructor, Config, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FSoftObjectPath                        MasterSubmix;                                      // 0x00D8(0x0020)(Edit, ZeroConstructor, Config, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FSoftObjectPath                        BaseDefaultSubmix;                                 // 0x00F8(0x0020)(Edit, ZeroConstructor, Config, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FSoftObjectPath                        ReverbSubmix;                                      // 0x0118(0x0020)(Edit, ZeroConstructor, Config, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FSoftObjectPath                        EQSubmix;                                          // 0x0138(0x0020)(Edit, ZeroConstructor, Config, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EVoiceSampleRate                              VoiPSampleRate;                                    // 0x0158(0x0004)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EDefaultAudioCompressionType                  DefaultAudioCompressionType;                       // 0x015C(0x0001)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_15D[0x3];                                      // 0x015D(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	int32                                         DefaultCompressionQuality;                         // 0x0160(0x0004)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         DefaultReverbSendLevel;                            // 0x0164(0x0004)(ZeroConstructor, Config, Deprecated, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         MaximumConcurrentStreams;                          // 0x0168(0x0004)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         GlobalMinPitchScale;                               // 0x016C(0x0004)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         GlobalMaxPitchScale;                               // 0x0170(0x0004)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_174[0x4];                                      // 0x0174(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<struct FAudioQualitySettings>          QualityLevels;                                     // 0x0178(0x0010)(Edit, ZeroConstructor, Config, NativeAccessSpecifierPublic)
	uint8                                         bAllowPlayWhenSilent : 1;                          // 0x0188(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, Config, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bDisableMasterEQ : 1;                              // 0x0188(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, Config, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bAllowCenterChannel3DPanning : 1;                  // 0x0188(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Edit, Config, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_189[0x3];                                      // 0x0189(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	uint32                                        NumStoppingSources;                                // 0x018C(0x0004)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EPanningMethod                                PanningMethod;                                     // 0x0190(0x0001)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EMonoChannelUpmixMethod                       MonoChannelUpmixMethod;                            // 0x0191(0x0001)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_192[0x6];                                      // 0x0192(0x0006)(Fixing Size After Last Property [ Dumper-7 ])
	class FString                                 DialogueFilenameFormat;                            // 0x0198(0x0010)(Edit, ZeroConstructor, Config, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TArray<struct FSoundDebugEntry>               DebugSounds;                                       // 0x01A8(0x0010)(Edit, ZeroConstructor, Config, NativeAccessSpecifierPublic)
	TArray<struct FDefaultAudioBusSettings>       DefaultAudioBuses;                                 // 0x01B8(0x0010)(Edit, ZeroConstructor, Config, NativeAccessSpecifierPublic)
	class USoundClass*                            DefaultSoundClass;                                 // 0x01C8(0x0008)(ZeroConstructor, Transient, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	class USoundClass*                            DefaultMediaSoundClass;                            // 0x01D0(0x0008)(ZeroConstructor, Transient, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	class USoundConcurrency*                      DefaultSoundConcurrency;                           // 0x01D8(0x0008)(ZeroConstructor, Transient, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_1E0[0x8];                                      // 0x01E0(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AudioSettings">();
	}
	static class UAudioSettings* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAudioSettings>();
	}
};
static_assert(alignof(UAudioSettings) == 0x000008, "Wrong alignment on UAudioSettings");
static_assert(sizeof(UAudioSettings) == 0x0001E8, "Wrong size on UAudioSettings");
static_assert(offsetof(UAudioSettings, DefaultSoundClassName) == 0x000038, "Member 'UAudioSettings::DefaultSoundClassName' has a wrong offset!");
static_assert(offsetof(UAudioSettings, DefaultMediaSoundClassName) == 0x000058, "Member 'UAudioSettings::DefaultMediaSoundClassName' has a wrong offset!");
static_assert(offsetof(UAudioSettings, DefaultSoundConcurrencyName) == 0x000078, "Member 'UAudioSettings::DefaultSoundConcurrencyName' has a wrong offset!");
static_assert(offsetof(UAudioSettings, DefaultBaseSoundMix) == 0x000098, "Member 'UAudioSettings::DefaultBaseSoundMix' has a wrong offset!");
static_assert(offsetof(UAudioSettings, VoiPSoundClass) == 0x0000B8, "Member 'UAudioSettings::VoiPSoundClass' has a wrong offset!");
static_assert(offsetof(UAudioSettings, MasterSubmix) == 0x0000D8, "Member 'UAudioSettings::MasterSubmix' has a wrong offset!");
static_assert(offsetof(UAudioSettings, BaseDefaultSubmix) == 0x0000F8, "Member 'UAudioSettings::BaseDefaultSubmix' has a wrong offset!");
static_assert(offsetof(UAudioSettings, ReverbSubmix) == 0x000118, "Member 'UAudioSettings::ReverbSubmix' has a wrong offset!");
static_assert(offsetof(UAudioSettings, EQSubmix) == 0x000138, "Member 'UAudioSettings::EQSubmix' has a wrong offset!");
static_assert(offsetof(UAudioSettings, VoiPSampleRate) == 0x000158, "Member 'UAudioSettings::VoiPSampleRate' has a wrong offset!");
static_assert(offsetof(UAudioSettings, DefaultAudioCompressionType) == 0x00015C, "Member 'UAudioSettings::DefaultAudioCompressionType' has a wrong offset!");
static_assert(offsetof(UAudioSettings, DefaultCompressionQuality) == 0x000160, "Member 'UAudioSettings::DefaultCompressionQuality' has a wrong offset!");
static_assert(offsetof(UAudioSettings, DefaultReverbSendLevel) == 0x000164, "Member 'UAudioSettings::DefaultReverbSendLevel' has a wrong offset!");
static_assert(offsetof(UAudioSettings, MaximumConcurrentStreams) == 0x000168, "Member 'UAudioSettings::MaximumConcurrentStreams' has a wrong offset!");
static_assert(offsetof(UAudioSettings, GlobalMinPitchScale) == 0x00016C, "Member 'UAudioSettings::GlobalMinPitchScale' has a wrong offset!");
static_assert(offsetof(UAudioSettings, GlobalMaxPitchScale) == 0x000170, "Member 'UAudioSettings::GlobalMaxPitchScale' has a wrong offset!");
static_assert(offsetof(UAudioSettings, QualityLevels) == 0x000178, "Member 'UAudioSettings::QualityLevels' has a wrong offset!");
static_assert(offsetof(UAudioSettings, NumStoppingSources) == 0x00018C, "Member 'UAudioSettings::NumStoppingSources' has a wrong offset!");
static_assert(offsetof(UAudioSettings, PanningMethod) == 0x000190, "Member 'UAudioSettings::PanningMethod' has a wrong offset!");
static_assert(offsetof(UAudioSettings, MonoChannelUpmixMethod) == 0x000191, "Member 'UAudioSettings::MonoChannelUpmixMethod' has a wrong offset!");
static_assert(offsetof(UAudioSettings, DialogueFilenameFormat) == 0x000198, "Member 'UAudioSettings::DialogueFilenameFormat' has a wrong offset!");
static_assert(offsetof(UAudioSettings, DebugSounds) == 0x0001A8, "Member 'UAudioSettings::DebugSounds' has a wrong offset!");
static_assert(offsetof(UAudioSettings, DefaultAudioBuses) == 0x0001B8, "Member 'UAudioSettings::DefaultAudioBuses' has a wrong offset!");
static_assert(offsetof(UAudioSettings, DefaultSoundClass) == 0x0001C8, "Member 'UAudioSettings::DefaultSoundClass' has a wrong offset!");
static_assert(offsetof(UAudioSettings, DefaultMediaSoundClass) == 0x0001D0, "Member 'UAudioSettings::DefaultMediaSoundClass' has a wrong offset!");
static_assert(offsetof(UAudioSettings, DefaultSoundConcurrency) == 0x0001D8, "Member 'UAudioSettings::DefaultSoundConcurrency' has a wrong offset!");

// Class Engine.AudioVolume
// 0x0070 (0x0348 - 0x02D8)
class AAudioVolume final : public AVolume
{
public:
	float                                         Priority;                                          // 0x02D8(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         bEnabled : 1;                                      // 0x02DC(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, Net, RepNotify, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate))
	uint8                                         Pad_2DD[0x3];                                      // 0x02DD(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	struct FReverbSettings                        Settings;                                          // 0x02E0(0x0020)(Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, NativeAccessSpecifierPrivate)
	struct FInteriorSettings                      AmbientZoneSettings;                               // 0x0300(0x0024)(Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, NativeAccessSpecifierPrivate)
	uint8                                         Pad_324[0x4];                                      // 0x0324(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<struct FAudioVolumeSubmixSendSettings> SubmixSendSettings;                                // 0x0328(0x0010)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, NativeAccessSpecifierPrivate)
	TArray<struct FAudioVolumeSubmixOverrideSettings> SubmixOverrideSettings;                        // 0x0338(0x0010)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, NativeAccessSpecifierPrivate)

public:
	void OnRep_bEnabled();
	void SetEnabled(bool bNewEnabled);
	void SetInteriorSettings(const struct FInteriorSettings& NewInteriorSettings);
	void SetPriority(float NewPriority);
	void SetReverbSettings(const struct FReverbSettings& NewReverbSettings);
	void SetSubmixOverrideSettings(const TArray<struct FAudioVolumeSubmixOverrideSettings>& NewSubmixOverrideSettings);
	void SetSubmixSendSettings(const TArray<struct FAudioVolumeSubmixSendSettings>& NewSubmixSendSettings);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AudioVolume">();
	}
	static class AAudioVolume* GetDefaultObj()
	{
		return GetDefaultObjImpl<AAudioVolume>();
	}
};
static_assert(alignof(AAudioVolume) == 0x000008, "Wrong alignment on AAudioVolume");
static_assert(sizeof(AAudioVolume) == 0x000348, "Wrong size on AAudioVolume");
static_assert(offsetof(AAudioVolume, Priority) == 0x0002D8, "Member 'AAudioVolume::Priority' has a wrong offset!");
static_assert(offsetof(AAudioVolume, Settings) == 0x0002E0, "Member 'AAudioVolume::Settings' has a wrong offset!");
static_assert(offsetof(AAudioVolume, AmbientZoneSettings) == 0x000300, "Member 'AAudioVolume::AmbientZoneSettings' has a wrong offset!");
static_assert(offsetof(AAudioVolume, SubmixSendSettings) == 0x000328, "Member 'AAudioVolume::SubmixSendSettings' has a wrong offset!");
static_assert(offsetof(AAudioVolume, SubmixOverrideSettings) == 0x000338, "Member 'AAudioVolume::SubmixOverrideSettings' has a wrong offset!");

// Class Engine.AudioParameterConversionStatics
// 0x0000 (0x0028 - 0x0028)
class UAudioParameterConversionStatics final : public UBlueprintFunctionLibrary
{
public:
	static struct FAudioParameter BooleanArrayToAudioParameter(class FName Name_0, const TArray<bool>& Bools);
	static struct FAudioParameter BooleanToAudioParameter(class FName Name_0, bool Bool);
	static struct FAudioParameter FloatArrayToAudioParameter(class FName Name_0, const TArray<float>& Floats);
	static struct FAudioParameter FloatToAudioParameter(class FName Name_0, float float_0);
	static struct FAudioParameter IntegerArrayToAudioParameter(class FName Name_0, const TArray<int32>& Integers);
	static struct FAudioParameter IntegerToAudioParameter(class FName Name_0, int32 Integer);
	static struct FAudioParameter ObjectArrayToAudioParameter(class FName Name_0, const TArray<class UObject*>& Objects);
	static struct FAudioParameter ObjectToAudioParameter(class FName Name_0, class UObject* Object);
	static struct FAudioParameter StringArrayToAudioParameter(class FName Name_0, const TArray<class FString>& Strings);
	static struct FAudioParameter StringToAudioParameter(class FName Name_0, const class FString& String);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AudioParameterConversionStatics">();
	}
	static class UAudioParameterConversionStatics* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAudioParameterConversionStatics>();
	}
};
static_assert(alignof(UAudioParameterConversionStatics) == 0x000008, "Wrong alignment on UAudioParameterConversionStatics");
static_assert(sizeof(UAudioParameterConversionStatics) == 0x000028, "Wrong size on UAudioParameterConversionStatics");

// Class Engine.BlockingVolume
// 0x0000 (0x02D8 - 0x02D8)
class ABlockingVolume final : public AVolume
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"BlockingVolume">();
	}
	static class ABlockingVolume* GetDefaultObj()
	{
		return GetDefaultObjImpl<ABlockingVolume>();
	}
};
static_assert(alignof(ABlockingVolume) == 0x000008, "Wrong alignment on ABlockingVolume");
static_assert(sizeof(ABlockingVolume) == 0x0002D8, "Wrong size on ABlockingVolume");

// Class Engine.BlueprintSetLibrary
// 0x0000 (0x0028 - 0x0028)
class UBlueprintSetLibrary final : public UBlueprintFunctionLibrary
{
public:
	static void Set_Add(const TSet<int32>& TargetSet, const int32& NewItem);
	static void Set_AddItems(const TSet<int32>& TargetSet, const TArray<int32>& NewItems);
	static void Set_Clear(const TSet<int32>& TargetSet);
	static bool Set_Contains(const TSet<int32>& TargetSet, const int32& ItemToFind);
	static void Set_Difference(const TSet<int32>& A, const TSet<int32>& B, TSet<int32>* Result);
	static void Set_Intersection(const TSet<int32>& A, const TSet<int32>& B, TSet<int32>* Result);
	static bool Set_IsEmpty(const TSet<int32>& TargetSet);
	static bool Set_IsNotEmpty(const TSet<int32>& TargetSet);
	static int32 Set_Length(const TSet<int32>& TargetSet);
	static bool Set_Remove(const TSet<int32>& TargetSet, const int32& Item);
	static void Set_RemoveItems(const TSet<int32>& TargetSet, const TArray<int32>& Items);
	static void Set_ToArray(const TSet<int32>& A, TArray<int32>* Result);
	static void Set_Union(const TSet<int32>& A, const TSet<int32>& B, TSet<int32>* Result);
	static void SetSetPropertyByName(class UObject* Object, class FName PropertyName, const TSet<int32>& Value);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"BlueprintSetLibrary">();
	}
	static class UBlueprintSetLibrary* GetDefaultObj()
	{
		return GetDefaultObjImpl<UBlueprintSetLibrary>();
	}
};
static_assert(alignof(UBlueprintSetLibrary) == 0x000008, "Wrong alignment on UBlueprintSetLibrary");
static_assert(sizeof(UBlueprintSetLibrary) == 0x000028, "Wrong size on UBlueprintSetLibrary");

// Class Engine.BookMark
// 0x0040 (0x0068 - 0x0028)
class UBookMark final : public UBookmarkBase
{
public:
	struct FVector                                Location;                                          // 0x0028(0x0018)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FRotator                               Rotation;                                          // 0x0040(0x0018)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
	TArray<class FString>                         HiddenLevels;                                      // 0x0058(0x0010)(Edit, ZeroConstructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"BookMark">();
	}
	static class UBookMark* GetDefaultObj()
	{
		return GetDefaultObjImpl<UBookMark>();
	}
};
static_assert(alignof(UBookMark) == 0x000008, "Wrong alignment on UBookMark");
static_assert(sizeof(UBookMark) == 0x000068, "Wrong size on UBookMark");
static_assert(offsetof(UBookMark, Location) == 0x000028, "Member 'UBookMark::Location' has a wrong offset!");
static_assert(offsetof(UBookMark, Rotation) == 0x000040, "Member 'UBookMark::Rotation' has a wrong offset!");
static_assert(offsetof(UBookMark, HiddenLevels) == 0x000058, "Member 'UBookMark::HiddenLevels' has a wrong offset!");

// Class Engine.CameraLensEffectInterface
// 0x0000 (0x0000 - 0x0000)
class ICameraLensEffectInterface final
{
public:
	TArray<class UFXSystemComponent*> GetParticleComponents() const;
	class UFXSystemComponent* GetPrimaryParticleComponent() const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"CameraLensEffectInterface">();
	}
	static class ICameraLensEffectInterface* GetDefaultObj()
	{
		return GetDefaultObjImpl<ICameraLensEffectInterface>();
	}

	class UObject* AsUObject()
	{
		return reinterpret_cast<UObject*>(this);
	}
	const class UObject* AsUObject() const
	{
		return reinterpret_cast<const UObject*>(this);
	}
};
static_assert(alignof(ICameraLensEffectInterface) == 0x000001, "Wrong alignment on ICameraLensEffectInterface");
static_assert(sizeof(ICameraLensEffectInterface) == 0x000001, "Wrong size on ICameraLensEffectInterface");

// Class Engine.CameraModifier_CameraShake
// 0x0068 (0x00B0 - 0x0048)
class UCameraModifier_CameraShake : public UCameraModifier
{
public:
	TArray<struct FActiveCameraShakeInfo>         ActiveShakes;                                      // 0x0048(0x0010)(ZeroConstructor, ContainsInstancedReference, Protected, NativeAccessSpecifierProtected)
	TMap<TSubclassOf<class UCameraShakeBase>, struct FPooledCameraShakes> ExpiredPooledShakesMap;    // 0x0058(0x0050)(Protected, NativeAccessSpecifierProtected)
	float                                         SplitScreenShakeScale;                             // 0x00A8(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_AC[0x4];                                       // 0x00AC(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"CameraModifier_CameraShake">();
	}
	static class UCameraModifier_CameraShake* GetDefaultObj()
	{
		return GetDefaultObjImpl<UCameraModifier_CameraShake>();
	}
};
static_assert(alignof(UCameraModifier_CameraShake) == 0x000008, "Wrong alignment on UCameraModifier_CameraShake");
static_assert(sizeof(UCameraModifier_CameraShake) == 0x0000B0, "Wrong size on UCameraModifier_CameraShake");
static_assert(offsetof(UCameraModifier_CameraShake, ActiveShakes) == 0x000048, "Member 'UCameraModifier_CameraShake::ActiveShakes' has a wrong offset!");
static_assert(offsetof(UCameraModifier_CameraShake, ExpiredPooledShakesMap) == 0x000058, "Member 'UCameraModifier_CameraShake::ExpiredPooledShakesMap' has a wrong offset!");
static_assert(offsetof(UCameraModifier_CameraShake, SplitScreenShakeScale) == 0x0000A8, "Member 'UCameraModifier_CameraShake::SplitScreenShakeScale' has a wrong offset!");

// Class Engine.CameraShakeBase
// 0x00B8 (0x00E0 - 0x0028)
#pragma pack(push, 0x1)
class alignas(0x10) UCameraShakeBase : public UObject
{
public:
	bool                                          bSingleInstance;                                   // 0x0028(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_29[0x3];                                       // 0x0029(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         ShakeScale;                                        // 0x002C(0x0004)(BlueprintVisible, ZeroConstructor, Transient, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UCameraShakePattern*                    RootShakePattern;                                  // 0x0030(0x0008)(Edit, ExportObject, ZeroConstructor, InstancedReference, NoDestructor, PersistentInstance, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	class APlayerCameraManager*                   CameraManager;                                     // 0x0038(0x0008)(ZeroConstructor, Transient, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_40[0x98];                                      // 0x0040(0x0098)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void SetRootShakePattern(class UCameraShakePattern* InPattern);

	class UCameraShakePattern* GetRootShakePattern() const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"CameraShakeBase">();
	}
	static class UCameraShakeBase* GetDefaultObj()
	{
		return GetDefaultObjImpl<UCameraShakeBase>();
	}
};
#pragma pack(pop)
static_assert(alignof(UCameraShakeBase) == 0x000010, "Wrong alignment on UCameraShakeBase");
static_assert(sizeof(UCameraShakeBase) == 0x0000E0, "Wrong size on UCameraShakeBase");
static_assert(offsetof(UCameraShakeBase, bSingleInstance) == 0x000028, "Member 'UCameraShakeBase::bSingleInstance' has a wrong offset!");
static_assert(offsetof(UCameraShakeBase, ShakeScale) == 0x00002C, "Member 'UCameraShakeBase::ShakeScale' has a wrong offset!");
static_assert(offsetof(UCameraShakeBase, RootShakePattern) == 0x000030, "Member 'UCameraShakeBase::RootShakePattern' has a wrong offset!");
static_assert(offsetof(UCameraShakeBase, CameraManager) == 0x000038, "Member 'UCameraShakeBase::CameraManager' has a wrong offset!");

// Class Engine.Character
// 0x0358 (0x0680 - 0x0328)
#pragma pack(push, 0x1)
class alignas(0x10) ACharacter : public APawn
{
public:
	class USkeletalMeshComponent*                 mesh;                                              // 0x0328(0x0008)(Edit, BlueprintVisible, ExportObject, BlueprintReadOnly, ZeroConstructor, EditConst, InstancedReference, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	class UCharacterMovementComponent*            CharacterMovement;                                 // 0x0330(0x0008)(Edit, BlueprintVisible, ExportObject, BlueprintReadOnly, ZeroConstructor, EditConst, InstancedReference, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	class UCapsuleComponent*                      CapsuleComponent;                                  // 0x0338(0x0008)(Edit, BlueprintVisible, ExportObject, BlueprintReadOnly, ZeroConstructor, EditConst, InstancedReference, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	struct FBasedMovementInfo                     BasedMovement;                                     // 0x0340(0x0050)(NoDestructor, ContainsInstancedReference, Protected, NativeAccessSpecifierProtected)
	struct FBasedMovementInfo                     ReplicatedBasedMovement;                           // 0x0390(0x0050)(Net, RepNotify, NoDestructor, ContainsInstancedReference, Protected, NativeAccessSpecifierProtected)
	float                                         AnimRootMotionTranslationScale;                    // 0x03E0(0x0004)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_3E4[0x4];                                      // 0x03E4(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	struct FVector                                BaseTranslationOffset;                             // 0x03E8(0x0018)(ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	struct FQuat                                  BaseRotationOffset;                                // 0x0400(0x0020)(IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	float                                         ReplicatedServerLastTransformUpdateTimeStamp;      // 0x0420(0x0004)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	float                                         ReplayLastTransformUpdateTimeStamp;                // 0x0424(0x0004)(Net, ZeroConstructor, IsPlainOldData, RepNotify, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         ReplicatedMovementMode;                            // 0x0428(0x0001)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_429[0x7];                                      // 0x0429(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	struct FVector_NetQuantizeNormal              ReplicatedGravityDirection;                        // 0x0430(0x0018)(Net, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	bool                                          bInBaseReplication;                                // 0x0448(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_449[0x1F];                                     // 0x0449(0x001F)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         CrouchedEyeHeight;                                 // 0x0468(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bIsCrouched : 1;                                   // 0x046C(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (BlueprintVisible, BlueprintReadOnly, Net, RepNotify, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bProxyIsJumpForceApplied : 1;                      // 0x046C(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Net, Transient, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bPressedJump : 1;                                  // 0x046C(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (BlueprintVisible, BlueprintReadOnly, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bClientUpdating : 1;                               // 0x046C(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (Transient, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bClientWasFalling : 1;                             // 0x046C(0x0001)(BitIndex: 0x04, PropSize: 0x0001 (Transient, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bClientResimulateRootMotion : 1;                   // 0x046C(0x0001)(BitIndex: 0x05, PropSize: 0x0001 (Transient, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bClientResimulateRootMotionSources : 1;            // 0x046C(0x0001)(BitIndex: 0x06, PropSize: 0x0001 (Transient, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bSimGravityDisabled : 1;                           // 0x046C(0x0001)(BitIndex: 0x07, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bClientCheckEncroachmentOnNetUpdate : 1;           // 0x046D(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Transient, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bServerMoveIgnoreRootMotion : 1;                   // 0x046D(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Transient, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bWasJumping : 1;                                   // 0x046D(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, DisableEditOnTemplate, Transient, EditConst, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_46E[0x2];                                      // 0x046E(0x0002)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         JumpKeyHoldTime;                                   // 0x0470(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, DisableEditOnTemplate, Transient, EditConst, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         JumpForceTimeRemaining;                            // 0x0474(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, DisableEditOnTemplate, Transient, EditConst, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         ProxyJumpForceStartedTime;                         // 0x0478(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, DisableEditOnTemplate, Transient, EditConst, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         JumpMaxHoldTime;                                   // 0x047C(0x0004)(Edit, BlueprintVisible, Net, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         JumpMaxCount;                                      // 0x0480(0x0004)(Edit, BlueprintVisible, Net, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         JumpCurrentCount;                                  // 0x0484(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, DisableEditOnTemplate, EditConst, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         JumpCurrentCountPreJump;                           // 0x0488(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, DisableEditOnTemplate, EditConst, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_48C[0x4];                                      // 0x048C(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	TMulticastInlineDelegate<void()>              OnReachedJumpApex;                                 // 0x0490(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	TMulticastInlineDelegate<void(const struct FHitResult& Hit)> LandedDelegate;                     // 0x04A0(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	TMulticastInlineDelegate<void(class ACharacter* Character, EMovementMode PrevMovementMode, uint8 PreviousCustomMode)> MovementModeChangedDelegate; // 0x04B0(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	TMulticastInlineDelegate<void(float DeltaSeconds, const struct FVector& OldLocation, const struct FVector& OldVelocity)> OnCharacterMovementUpdated; // 0x04C0(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	struct FRootMotionSourceGroup                 SavedRootMotion;                                   // 0x04D0(0x0048)(Transient, NativeAccessSpecifierPublic)
	uint8                                         Pad_518[0x8];                                      // 0x0518(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	struct FRootMotionMovementParams              ClientRootMotionParams;                            // 0x0520(0x0070)(Transient, NoDestructor, NativeAccessSpecifierPublic)
	TArray<struct FSimulatedRootMotionReplicatedMove> RootMotionRepMoves;                            // 0x0590(0x0010)(ZeroConstructor, Transient, ContainsInstancedReference, NativeAccessSpecifierPublic)
	struct FRepRootMotionMontage                  RepRootMotion;                                     // 0x05A0(0x00D8)(Net, RepNotify, ContainsInstancedReference, NativeAccessSpecifierPublic)

public:
	void CacheInitialMeshOffset(const struct FVector& MeshRelativeLocation, const struct FRotator& MeshRelativeRotation);
	void ClientAckGoodMove(float Timestamp);
	void ClientAdjustPosition(float Timestamp, const struct FVector& NewLoc, const struct FVector& NewVel, class UPrimitiveComponent* NewBase, class FName NewBaseBoneName, bool bHasBase, bool bBaseRelativePosition, uint8 ServerMovementMode);
	void ClientAdjustRootMotionPosition(float Timestamp, float ServerMontageTrackPosition, const struct FVector& ServerLoc, const struct FVector_NetQuantizeNormal& ServerRotation, float ServerVelZ, class UPrimitiveComponent* ServerBase, class FName ServerBoneName, bool bHasBase, bool bBaseRelativePosition, uint8 ServerMovementMode);
	void ClientAdjustRootMotionSourcePosition(float Timestamp, const struct FRootMotionSourceGroup& ServerRootMotion, bool bHasAnimRootMotion, float ServerMontageTrackPosition, const struct FVector& ServerLoc, const struct FVector_NetQuantizeNormal& ServerRotation, float ServerVelZ, class UPrimitiveComponent* ServerBase, class FName ServerBoneName, bool bHasBase, bool bBaseRelativePosition, uint8 ServerMovementMode);
	void ClientCheatFly();
	void ClientCheatGhost();
	void ClientCheatWalk();
	void ClientMoveResponsePacked(const struct FCharacterMoveResponsePackedBits& PackedBits);
	void ClientVeryShortAdjustPosition(float Timestamp, const struct FVector& NewLoc, class UPrimitiveComponent* NewBase, class FName NewBaseBoneName, bool bHasBase, bool bBaseRelativePosition, uint8 ServerMovementMode);
	void Crouch(bool bClientSimulation);
	void Jump();
	void K2_OnEndCrouch(float HalfHeightAdjust, float ScaledHalfHeightAdjust);
	void K2_OnMovementModeChanged(EMovementMode PrevMovementMode, EMovementMode NewMovementMode, uint8 PrevCustomMode, uint8 NewCustomMode);
	void K2_OnStartCrouch(float HalfHeightAdjust, float ScaledHalfHeightAdjust);
	void K2_UpdateCustomMovement(float DeltaTime);
	void LaunchCharacter(const struct FVector& LaunchVelocity, bool bXYOverride, bool bZOverride);
	void OnJumped();
	void OnLanded(const struct FHitResult& Hit);
	void OnLaunched(const struct FVector& LaunchVelocity, bool bXYOverride, bool bZOverride);
	void OnRep_IsCrouched();
	void OnRep_ReplayLastTransformUpdateTimeStamp();
	void OnRep_ReplicatedBasedMovement();
	void OnRep_RootMotion();
	void OnWalkingOffLedge(const struct FVector& PreviousFloorImpactNormal, const struct FVector& PreviousFloorContactNormal, const struct FVector& PreviousLocation, float TimeDelta);
	float PlayAnimMontage(class UAnimMontage* AnimMontage, float InPlayRate, class FName StartSectionName);
	void RootMotionDebugClientPrintOnScreen(const class FString& InString);
	void ServerMove(float Timestamp, const struct FVector_NetQuantize10& InAccel, const struct FVector_NetQuantize100& ClientLoc, uint8 CompressedMoveFlags, uint8 ClientRoll, uint32 View, class UPrimitiveComponent* ClientMovementBase, class FName ClientBaseBoneName, uint8 ClientMovementMode);
	void ServerMoveDual(float TimeStamp0, const struct FVector_NetQuantize10& InAccel0, uint8 PendingFlags, uint32 View0, float Timestamp, const struct FVector_NetQuantize10& InAccel, const struct FVector_NetQuantize100& ClientLoc, uint8 NewFlags, uint8 ClientRoll, uint32 View, class UPrimitiveComponent* ClientMovementBase, class FName ClientBaseBoneName, uint8 ClientMovementMode);
	void ServerMoveDualHybridRootMotion(float TimeStamp0, const struct FVector_NetQuantize10& InAccel0, uint8 PendingFlags, uint32 View0, float Timestamp, const struct FVector_NetQuantize10& InAccel, const struct FVector_NetQuantize100& ClientLoc, uint8 NewFlags, uint8 ClientRoll, uint32 View, class UPrimitiveComponent* ClientMovementBase, class FName ClientBaseBoneName, uint8 ClientMovementMode);
	void ServerMoveDualNoBase(float TimeStamp0, const struct FVector_NetQuantize10& InAccel0, uint8 PendingFlags, uint32 View0, float Timestamp, const struct FVector_NetQuantize10& InAccel, const struct FVector_NetQuantize100& ClientLoc, uint8 NewFlags, uint8 ClientRoll, uint32 View, uint8 ClientMovementMode);
	void ServerMoveNoBase(float Timestamp, const struct FVector_NetQuantize10& InAccel, const struct FVector_NetQuantize100& ClientLoc, uint8 CompressedMoveFlags, uint8 ClientRoll, uint32 View, uint8 ClientMovementMode);
	void ServerMoveOld(float OldTimeStamp, const struct FVector_NetQuantize10& OldAccel, uint8 OldMoveFlags);
	void ServerMovePacked(const struct FCharacterServerMovePackedBits& PackedBits);
	void StopAnimMontage(class UAnimMontage* AnimMontage);
	void StopJumping();
	void UnCrouch(bool bClientSimulation);

	bool CanCrouch() const;
	bool CanJump() const;
	bool CanJumpInternal() const;
	float GetAnimRootMotionTranslationScale() const;
	struct FRotator GetBaseRotationOffsetRotator() const;
	struct FVector GetBaseTranslationOffset() const;
	class UAnimMontage* GetCurrentMontage() const;
	bool HasAnyRootMotion() const;
	bool IsJumpProvidingForce() const;
	bool IsPlayingNetworkedRootMotionMontage() const;
	bool IsPlayingRootMotion() const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"Character">();
	}
	static class ACharacter* GetDefaultObj()
	{
		return GetDefaultObjImpl<ACharacter>();
	}
};
#pragma pack(pop)
static_assert(alignof(ACharacter) == 0x000010, "Wrong alignment on ACharacter");
static_assert(sizeof(ACharacter) == 0x000680, "Wrong size on ACharacter");
static_assert(offsetof(ACharacter, mesh) == 0x000328, "Member 'ACharacter::mesh' has a wrong offset!");
static_assert(offsetof(ACharacter, CharacterMovement) == 0x000330, "Member 'ACharacter::CharacterMovement' has a wrong offset!");
static_assert(offsetof(ACharacter, CapsuleComponent) == 0x000338, "Member 'ACharacter::CapsuleComponent' has a wrong offset!");
static_assert(offsetof(ACharacter, BasedMovement) == 0x000340, "Member 'ACharacter::BasedMovement' has a wrong offset!");
static_assert(offsetof(ACharacter, ReplicatedBasedMovement) == 0x000390, "Member 'ACharacter::ReplicatedBasedMovement' has a wrong offset!");
static_assert(offsetof(ACharacter, AnimRootMotionTranslationScale) == 0x0003E0, "Member 'ACharacter::AnimRootMotionTranslationScale' has a wrong offset!");
static_assert(offsetof(ACharacter, BaseTranslationOffset) == 0x0003E8, "Member 'ACharacter::BaseTranslationOffset' has a wrong offset!");
static_assert(offsetof(ACharacter, BaseRotationOffset) == 0x000400, "Member 'ACharacter::BaseRotationOffset' has a wrong offset!");
static_assert(offsetof(ACharacter, ReplicatedServerLastTransformUpdateTimeStamp) == 0x000420, "Member 'ACharacter::ReplicatedServerLastTransformUpdateTimeStamp' has a wrong offset!");
static_assert(offsetof(ACharacter, ReplayLastTransformUpdateTimeStamp) == 0x000424, "Member 'ACharacter::ReplayLastTransformUpdateTimeStamp' has a wrong offset!");
static_assert(offsetof(ACharacter, ReplicatedMovementMode) == 0x000428, "Member 'ACharacter::ReplicatedMovementMode' has a wrong offset!");
static_assert(offsetof(ACharacter, ReplicatedGravityDirection) == 0x000430, "Member 'ACharacter::ReplicatedGravityDirection' has a wrong offset!");
static_assert(offsetof(ACharacter, bInBaseReplication) == 0x000448, "Member 'ACharacter::bInBaseReplication' has a wrong offset!");
static_assert(offsetof(ACharacter, CrouchedEyeHeight) == 0x000468, "Member 'ACharacter::CrouchedEyeHeight' has a wrong offset!");
static_assert(offsetof(ACharacter, JumpKeyHoldTime) == 0x000470, "Member 'ACharacter::JumpKeyHoldTime' has a wrong offset!");
static_assert(offsetof(ACharacter, JumpForceTimeRemaining) == 0x000474, "Member 'ACharacter::JumpForceTimeRemaining' has a wrong offset!");
static_assert(offsetof(ACharacter, ProxyJumpForceStartedTime) == 0x000478, "Member 'ACharacter::ProxyJumpForceStartedTime' has a wrong offset!");
static_assert(offsetof(ACharacter, JumpMaxHoldTime) == 0x00047C, "Member 'ACharacter::JumpMaxHoldTime' has a wrong offset!");
static_assert(offsetof(ACharacter, JumpMaxCount) == 0x000480, "Member 'ACharacter::JumpMaxCount' has a wrong offset!");
static_assert(offsetof(ACharacter, JumpCurrentCount) == 0x000484, "Member 'ACharacter::JumpCurrentCount' has a wrong offset!");
static_assert(offsetof(ACharacter, JumpCurrentCountPreJump) == 0x000488, "Member 'ACharacter::JumpCurrentCountPreJump' has a wrong offset!");
static_assert(offsetof(ACharacter, OnReachedJumpApex) == 0x000490, "Member 'ACharacter::OnReachedJumpApex' has a wrong offset!");
static_assert(offsetof(ACharacter, LandedDelegate) == 0x0004A0, "Member 'ACharacter::LandedDelegate' has a wrong offset!");
static_assert(offsetof(ACharacter, MovementModeChangedDelegate) == 0x0004B0, "Member 'ACharacter::MovementModeChangedDelegate' has a wrong offset!");
static_assert(offsetof(ACharacter, OnCharacterMovementUpdated) == 0x0004C0, "Member 'ACharacter::OnCharacterMovementUpdated' has a wrong offset!");
static_assert(offsetof(ACharacter, SavedRootMotion) == 0x0004D0, "Member 'ACharacter::SavedRootMotion' has a wrong offset!");
static_assert(offsetof(ACharacter, ClientRootMotionParams) == 0x000520, "Member 'ACharacter::ClientRootMotionParams' has a wrong offset!");
static_assert(offsetof(ACharacter, RootMotionRepMoves) == 0x000590, "Member 'ACharacter::RootMotionRepMoves' has a wrong offset!");
static_assert(offsetof(ACharacter, RepRootMotion) == 0x0005A0, "Member 'ACharacter::RepRootMotion' has a wrong offset!");

// Class Engine.CheatManagerExtension
// 0x0000 (0x0028 - 0x0028)
class UCheatManagerExtension final : public UObject
{
public:
	void AddedToCheatManager();
	void RemovedFromCheatManager();

	class APlayerController* GetPlayerController() const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"CheatManagerExtension">();
	}
	static class UCheatManagerExtension* GetDefaultObj()
	{
		return GetDefaultObjImpl<UCheatManagerExtension>();
	}
};
static_assert(alignof(UCheatManagerExtension) == 0x000008, "Wrong alignment on UCheatManagerExtension");
static_assert(sizeof(UCheatManagerExtension) == 0x000028, "Wrong size on UCheatManagerExtension");

// Class Engine.SmokeTestCommandlet
// 0x0000 (0x0080 - 0x0080)
class USmokeTestCommandlet final : public UCommandlet
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"SmokeTestCommandlet">();
	}
	static class USmokeTestCommandlet* GetDefaultObj()
	{
		return GetDefaultObjImpl<USmokeTestCommandlet>();
	}
};
static_assert(alignof(USmokeTestCommandlet) == 0x000008, "Wrong alignment on USmokeTestCommandlet");
static_assert(sizeof(USmokeTestCommandlet) == 0x000080, "Wrong size on USmokeTestCommandlet");

// Class Engine.InitialActiveSoundParams
// 0x0010 (0x0038 - 0x0028)
class UInitialActiveSoundParams final : public UObject
{
public:
	TArray<struct FAudioParameter>                AudioParams;                                       // 0x0028(0x0010)(Edit, BlueprintVisible, ZeroConstructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"InitialActiveSoundParams">();
	}
	static class UInitialActiveSoundParams* GetDefaultObj()
	{
		return GetDefaultObjImpl<UInitialActiveSoundParams>();
	}
};
static_assert(alignof(UInitialActiveSoundParams) == 0x000008, "Wrong alignment on UInitialActiveSoundParams");
static_assert(sizeof(UInitialActiveSoundParams) == 0x000038, "Wrong size on UInitialActiveSoundParams");
static_assert(offsetof(UInitialActiveSoundParams, AudioParams) == 0x000028, "Member 'UInitialActiveSoundParams::AudioParams' has a wrong offset!");

// Class Engine.ChildActorComponent
// 0x0040 (0x02E0 - 0x02A0)
class UChildActorComponent final : public USceneComponent
{
public:
	TSubclassOf<class AActor>                     ChildActorClass;                                   // 0x02A0(0x0008)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	class AActor*                                 ChildActor;                                        // 0x02A8(0x0008)(BlueprintVisible, BlueprintReadOnly, Net, ZeroConstructor, RepNotify, NoDestructor, TextExportTransient, NonPIEDuplicateTransient, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	class AActor*                                 ChildActorTemplate;                                // 0x02B0(0x0008)(Edit, ZeroConstructor, DisableEditOnInstance, EditConst, DuplicateTransient, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_2B8[0x18];                                     // 0x02B8(0x0018)(Fixing Size After Last Property [ Dumper-7 ])
	uint8                                         bChildActorIsTransient : 1;                        // 0x02D0(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, DisableEditOnInstance, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate))
	uint8                                         Pad_2D1[0xF];                                      // 0x02D1(0x000F)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void OnChildActorDestroyed(class AActor* Actor);
	void OnRep_ChildActor();
	void SetChildActorClass(TSubclassOf<class AActor> InClass);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ChildActorComponent">();
	}
	static class UChildActorComponent* GetDefaultObj()
	{
		return GetDefaultObjImpl<UChildActorComponent>();
	}
};
static_assert(alignof(UChildActorComponent) == 0x000010, "Wrong alignment on UChildActorComponent");
static_assert(sizeof(UChildActorComponent) == 0x0002E0, "Wrong size on UChildActorComponent");
static_assert(offsetof(UChildActorComponent, ChildActorClass) == 0x0002A0, "Member 'UChildActorComponent::ChildActorClass' has a wrong offset!");
static_assert(offsetof(UChildActorComponent, ChildActor) == 0x0002A8, "Member 'UChildActorComponent::ChildActor' has a wrong offset!");
static_assert(offsetof(UChildActorComponent, ChildActorTemplate) == 0x0002B0, "Member 'UChildActorComponent::ChildActorTemplate' has a wrong offset!");

// Class Engine.DrawFrustumComponent
// 0x0020 (0x0590 - 0x0570)
class UDrawFrustumComponent final : public UPrimitiveComponent
{
public:
	bool                                          bFrustumEnabled;                                   // 0x0570(0x0001)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_571[0x3];                                      // 0x0571(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	struct FColor                                 FrustumColor;                                      // 0x0574(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         FrustumAngle;                                      // 0x0578(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         FrustumAspectRatio;                                // 0x057C(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         FrustumStartDist;                                  // 0x0580(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         FrustumEndDist;                                    // 0x0584(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UTexture*                               Texture;                                           // 0x0588(0x0008)(Edit, BlueprintVisible, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"DrawFrustumComponent">();
	}
	static class UDrawFrustumComponent* GetDefaultObj()
	{
		return GetDefaultObjImpl<UDrawFrustumComponent>();
	}
};
static_assert(alignof(UDrawFrustumComponent) == 0x000010, "Wrong alignment on UDrawFrustumComponent");
static_assert(sizeof(UDrawFrustumComponent) == 0x000590, "Wrong size on UDrawFrustumComponent");
static_assert(offsetof(UDrawFrustumComponent, bFrustumEnabled) == 0x000570, "Member 'UDrawFrustumComponent::bFrustumEnabled' has a wrong offset!");
static_assert(offsetof(UDrawFrustumComponent, FrustumColor) == 0x000574, "Member 'UDrawFrustumComponent::FrustumColor' has a wrong offset!");
static_assert(offsetof(UDrawFrustumComponent, FrustumAngle) == 0x000578, "Member 'UDrawFrustumComponent::FrustumAngle' has a wrong offset!");
static_assert(offsetof(UDrawFrustumComponent, FrustumAspectRatio) == 0x00057C, "Member 'UDrawFrustumComponent::FrustumAspectRatio' has a wrong offset!");
static_assert(offsetof(UDrawFrustumComponent, FrustumStartDist) == 0x000580, "Member 'UDrawFrustumComponent::FrustumStartDist' has a wrong offset!");
static_assert(offsetof(UDrawFrustumComponent, FrustumEndDist) == 0x000584, "Member 'UDrawFrustumComponent::FrustumEndDist' has a wrong offset!");
static_assert(offsetof(UDrawFrustumComponent, Texture) == 0x000588, "Member 'UDrawFrustumComponent::Texture' has a wrong offset!");

// Class Engine.HeterogeneousVolumeComponent
// 0x0040 (0x05F0 - 0x05B0)
class UHeterogeneousVolumeComponent final : public UMeshComponent
{
public:
	struct FIntVector                             VolumeResolution;                                  // 0x05A8(0x000C)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         frame;                                             // 0x05B4(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         FrameRate;                                         // 0x05B8(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         StartFrame;                                        // 0x05BC(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         EndFrame;                                          // 0x05C0(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bPlaying : 1;                                      // 0x05C4(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bLooping : 1;                                      // 0x05C4(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_5C5[0x3];                                      // 0x05C5(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	uint32                                        MipLevel;                                          // 0x05C8(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bIssueBlockingRequests : 1;                        // 0x05CC(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_5CD[0x3];                                      // 0x05CD(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         StepFactor;                                        // 0x05D0(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         ShadowStepFactor;                                  // 0x05D4(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         ShadowBiasFactor;                                  // 0x05D8(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         LightingDownsampleFactor;                          // 0x05DC(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UMaterialInstanceDynamic*               MaterialInstanceDynamic;                           // 0x05E0(0x0008)(ZeroConstructor, Transient, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_5E8[0x8];                                      // 0x05E8(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void Play();
	void SetEndFrame(float NewValue);
	void SetFrame(float NewValue);
	void SetFrameRate(float NewValue);
	void SetLooping(bool NewValue);
	void SetPlaying(bool NewValue);
	void SetStartFrame(float NewValue);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"HeterogeneousVolumeComponent">();
	}
	static class UHeterogeneousVolumeComponent* GetDefaultObj()
	{
		return GetDefaultObjImpl<UHeterogeneousVolumeComponent>();
	}
};
static_assert(alignof(UHeterogeneousVolumeComponent) == 0x000010, "Wrong alignment on UHeterogeneousVolumeComponent");
static_assert(sizeof(UHeterogeneousVolumeComponent) == 0x0005F0, "Wrong size on UHeterogeneousVolumeComponent");
static_assert(offsetof(UHeterogeneousVolumeComponent, VolumeResolution) == 0x0005A8, "Member 'UHeterogeneousVolumeComponent::VolumeResolution' has a wrong offset!");
static_assert(offsetof(UHeterogeneousVolumeComponent, frame) == 0x0005B4, "Member 'UHeterogeneousVolumeComponent::frame' has a wrong offset!");
static_assert(offsetof(UHeterogeneousVolumeComponent, FrameRate) == 0x0005B8, "Member 'UHeterogeneousVolumeComponent::FrameRate' has a wrong offset!");
static_assert(offsetof(UHeterogeneousVolumeComponent, StartFrame) == 0x0005BC, "Member 'UHeterogeneousVolumeComponent::StartFrame' has a wrong offset!");
static_assert(offsetof(UHeterogeneousVolumeComponent, EndFrame) == 0x0005C0, "Member 'UHeterogeneousVolumeComponent::EndFrame' has a wrong offset!");
static_assert(offsetof(UHeterogeneousVolumeComponent, MipLevel) == 0x0005C8, "Member 'UHeterogeneousVolumeComponent::MipLevel' has a wrong offset!");
static_assert(offsetof(UHeterogeneousVolumeComponent, StepFactor) == 0x0005D0, "Member 'UHeterogeneousVolumeComponent::StepFactor' has a wrong offset!");
static_assert(offsetof(UHeterogeneousVolumeComponent, ShadowStepFactor) == 0x0005D4, "Member 'UHeterogeneousVolumeComponent::ShadowStepFactor' has a wrong offset!");
static_assert(offsetof(UHeterogeneousVolumeComponent, ShadowBiasFactor) == 0x0005D8, "Member 'UHeterogeneousVolumeComponent::ShadowBiasFactor' has a wrong offset!");
static_assert(offsetof(UHeterogeneousVolumeComponent, LightingDownsampleFactor) == 0x0005DC, "Member 'UHeterogeneousVolumeComponent::LightingDownsampleFactor' has a wrong offset!");
static_assert(offsetof(UHeterogeneousVolumeComponent, MaterialInstanceDynamic) == 0x0005E0, "Member 'UHeterogeneousVolumeComponent::MaterialInstanceDynamic' has a wrong offset!");

// Class Engine.LocalLightComponent
// 0x0020 (0x0410 - 0x03F0)
class ULocalLightComponent : public ULightComponent
{
public:
	ELightUnits                                   IntensityUnits;                                    // 0x03F0(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_3F1[0x3];                                      // 0x03F1(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         InverseExposureBlend;                              // 0x03F4(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         Radius;                                            // 0x03F8(0x0004)(ZeroConstructor, Deprecated, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         AttenuationRadius;                                 // 0x03FC(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FLightmassPointLightSettings           LightmassSettings;                                 // 0x0400(0x000C)(Edit, NoDestructor, NativeAccessSpecifierPublic)
	uint8                                         Pad_40C[0x4];                                      // 0x040C(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static float GetUnitsConversionFactor(ELightUnits SrcUnits, ELightUnits TargetUnits, float CosHalfConeAngle);

	void SetAttenuationRadius(float NewRadius);
	void SetIntensityUnits(ELightUnits NewIntensityUnits);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"LocalLightComponent">();
	}
	static class ULocalLightComponent* GetDefaultObj()
	{
		return GetDefaultObjImpl<ULocalLightComponent>();
	}
};
static_assert(alignof(ULocalLightComponent) == 0x000010, "Wrong alignment on ULocalLightComponent");
static_assert(sizeof(ULocalLightComponent) == 0x000410, "Wrong size on ULocalLightComponent");
static_assert(offsetof(ULocalLightComponent, IntensityUnits) == 0x0003F0, "Member 'ULocalLightComponent::IntensityUnits' has a wrong offset!");
static_assert(offsetof(ULocalLightComponent, InverseExposureBlend) == 0x0003F4, "Member 'ULocalLightComponent::InverseExposureBlend' has a wrong offset!");
static_assert(offsetof(ULocalLightComponent, Radius) == 0x0003F8, "Member 'ULocalLightComponent::Radius' has a wrong offset!");
static_assert(offsetof(ULocalLightComponent, AttenuationRadius) == 0x0003FC, "Member 'ULocalLightComponent::AttenuationRadius' has a wrong offset!");
static_assert(offsetof(ULocalLightComponent, LightmassSettings) == 0x000400, "Member 'ULocalLightComponent::LightmassSettings' has a wrong offset!");

// Class Engine.LODSyncComponent
// 0x0098 (0x0140 - 0x00A8)
class ULODSyncComponent final : public UActorComponent
{
public:
	int32                                         NumLODs;                                           // 0x00A8(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         ForcedLOD;                                         // 0x00AC(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         MinLOD;                                            // 0x00B0(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_B4[0x4];                                       // 0x00B4(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<struct FComponentSync>                 ComponentsToSync;                                  // 0x00B8(0x0010)(Edit, BlueprintVisible, ZeroConstructor, NativeAccessSpecifierPublic)
	TMap<class FName, struct FLODMappingData>     CustomLODMapping;                                  // 0x00C8(0x0050)(Edit, BlueprintVisible, NativeAccessSpecifierPublic)
	int32                                         CurrentLOD;                                        // 0x0118(0x0004)(ZeroConstructor, Transient, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	int32                                         CurrentNumLODs;                                    // 0x011C(0x0004)(ZeroConstructor, Transient, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	TArray<class UPrimitiveComponent*>            DriveComponents;                                   // 0x0120(0x0010)(ExportObject, ZeroConstructor, Transient, ContainsInstancedReference, UObjectWrapper, NativeAccessSpecifierPrivate)
	TArray<class UPrimitiveComponent*>            SubComponents;                                     // 0x0130(0x0010)(ExportObject, ZeroConstructor, Transient, ContainsInstancedReference, UObjectWrapper, NativeAccessSpecifierPrivate)

public:
	class FString GetLODSyncDebugText() const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"LODSyncComponent">();
	}
	static class ULODSyncComponent* GetDefaultObj()
	{
		return GetDefaultObjImpl<ULODSyncComponent>();
	}
};
static_assert(alignof(ULODSyncComponent) == 0x000008, "Wrong alignment on ULODSyncComponent");
static_assert(sizeof(ULODSyncComponent) == 0x000140, "Wrong size on ULODSyncComponent");
static_assert(offsetof(ULODSyncComponent, NumLODs) == 0x0000A8, "Member 'ULODSyncComponent::NumLODs' has a wrong offset!");
static_assert(offsetof(ULODSyncComponent, ForcedLOD) == 0x0000AC, "Member 'ULODSyncComponent::ForcedLOD' has a wrong offset!");
static_assert(offsetof(ULODSyncComponent, MinLOD) == 0x0000B0, "Member 'ULODSyncComponent::MinLOD' has a wrong offset!");
static_assert(offsetof(ULODSyncComponent, ComponentsToSync) == 0x0000B8, "Member 'ULODSyncComponent::ComponentsToSync' has a wrong offset!");
static_assert(offsetof(ULODSyncComponent, CustomLODMapping) == 0x0000C8, "Member 'ULODSyncComponent::CustomLODMapping' has a wrong offset!");
static_assert(offsetof(ULODSyncComponent, CurrentLOD) == 0x000118, "Member 'ULODSyncComponent::CurrentLOD' has a wrong offset!");
static_assert(offsetof(ULODSyncComponent, CurrentNumLODs) == 0x00011C, "Member 'ULODSyncComponent::CurrentNumLODs' has a wrong offset!");
static_assert(offsetof(ULODSyncComponent, DriveComponents) == 0x000120, "Member 'ULODSyncComponent::DriveComponents' has a wrong offset!");
static_assert(offsetof(ULODSyncComponent, SubComponents) == 0x000130, "Member 'ULODSyncComponent::SubComponents' has a wrong offset!");

// Class Engine.MaterialBillboardComponent
// 0x0010 (0x0580 - 0x0570)
class UMaterialBillboardComponent final : public UPrimitiveComponent
{
public:
	TArray<struct FMaterialSpriteElement>         Elements;                                          // 0x0570(0x0010)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, NativeAccessSpecifierPublic)

public:
	void AddElement(class UMaterialInterface* Material, class UCurveFloat* DistanceToOpacityCurve, bool bSizeIsInScreenSpace, float BaseSizeX, float BaseSizeY, class UCurveFloat* DistanceToSizeCurve);
	void SetElements(const TArray<struct FMaterialSpriteElement>& NewElements);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialBillboardComponent">();
	}
	static class UMaterialBillboardComponent* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialBillboardComponent>();
	}
};
static_assert(alignof(UMaterialBillboardComponent) == 0x000010, "Wrong alignment on UMaterialBillboardComponent");
static_assert(sizeof(UMaterialBillboardComponent) == 0x000580, "Wrong size on UMaterialBillboardComponent");
static_assert(offsetof(UMaterialBillboardComponent, Elements) == 0x000570, "Member 'UMaterialBillboardComponent::Elements' has a wrong offset!");

// Class Engine.PlatformEventsComponent
// 0x0020 (0x00C8 - 0x00A8)
class UPlatformEventsComponent final : public UActorComponent
{
public:
	TMulticastInlineDelegate<void()>              PlatformChangedToLaptopModeDelegate;               // 0x00A8(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	TMulticastInlineDelegate<void()>              PlatformChangedToTabletModeDelegate;               // 0x00B8(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)

public:
	bool IsInLaptopMode();
	bool IsInTabletMode();
	bool SupportsConvertibleLaptops();

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"PlatformEventsComponent">();
	}
	static class UPlatformEventsComponent* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPlatformEventsComponent>();
	}
};
static_assert(alignof(UPlatformEventsComponent) == 0x000008, "Wrong alignment on UPlatformEventsComponent");
static_assert(sizeof(UPlatformEventsComponent) == 0x0000C8, "Wrong size on UPlatformEventsComponent");
static_assert(offsetof(UPlatformEventsComponent, PlatformChangedToLaptopModeDelegate) == 0x0000A8, "Member 'UPlatformEventsComponent::PlatformChangedToLaptopModeDelegate' has a wrong offset!");
static_assert(offsetof(UPlatformEventsComponent, PlatformChangedToTabletModeDelegate) == 0x0000B8, "Member 'UPlatformEventsComponent::PlatformChangedToTabletModeDelegate' has a wrong offset!");

// Class Engine.PointLightComponent
// 0x0020 (0x0430 - 0x0410)
#pragma pack(push, 0x1)
class alignas(0x10) UPointLightComponent : public ULocalLightComponent
{
public:
	uint8                                         bUseInverseSquaredFalloff : 1;                     // 0x0410(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_411[0x3];                                      // 0x0411(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         LightFalloffExponent;                              // 0x0414(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         SourceRadius;                                      // 0x0418(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         SoftSourceRadius;                                  // 0x041C(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         SourceLength;                                      // 0x0420(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_424[0x4];                                      // 0x0424(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void SetInverseExposureBlend(float NewInverseExposureBlend);
	void SetLightFalloffExponent(float NewLightFalloffExponent);
	void SetSoftSourceRadius(float bNewValue);
	void SetSourceLength(float NewValue);
	void SetSourceRadius(float bNewValue);
	void SetUseInverseSquaredFalloff(bool bNewValue);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"PointLightComponent">();
	}
	static class UPointLightComponent* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPointLightComponent>();
	}
};
#pragma pack(pop)
static_assert(alignof(UPointLightComponent) == 0x000010, "Wrong alignment on UPointLightComponent");
static_assert(sizeof(UPointLightComponent) == 0x000430, "Wrong size on UPointLightComponent");
static_assert(offsetof(UPointLightComponent, LightFalloffExponent) == 0x000414, "Member 'UPointLightComponent::LightFalloffExponent' has a wrong offset!");
static_assert(offsetof(UPointLightComponent, SourceRadius) == 0x000418, "Member 'UPointLightComponent::SourceRadius' has a wrong offset!");
static_assert(offsetof(UPointLightComponent, SoftSourceRadius) == 0x00041C, "Member 'UPointLightComponent::SoftSourceRadius' has a wrong offset!");
static_assert(offsetof(UPointLightComponent, SourceLength) == 0x000420, "Member 'UPointLightComponent::SourceLength' has a wrong offset!");

// Class Engine.ProjectileMovementComponent
// 0x0150 (0x0260 - 0x0110)
class alignas(0x10) UProjectileMovementComponent final : public UMovementComponent
{
public:
	float                                         InitialSpeed;                                      // 0x0110(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         MaxSpeed;                                          // 0x0114(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bRotationFollowsVelocity : 1;                      // 0x0118(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bRotationRemainsVertical : 1;                      // 0x0118(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bShouldBounce : 1;                                 // 0x0118(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bInitialVelocityInLocalSpace : 1;                  // 0x0118(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bForceSubStepping : 1;                             // 0x0118(0x0001)(BitIndex: 0x04, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bSimulationEnabled : 1;                            // 0x0118(0x0001)(BitIndex: 0x05, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bSweepCollision : 1;                               // 0x0118(0x0001)(BitIndex: 0x06, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bIsHomingProjectile : 1;                           // 0x0118(0x0001)(BitIndex: 0x07, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bBounceAngleAffectsFriction : 1;                   // 0x0119(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bIsSliding : 1;                                    // 0x0119(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, DisableEditOnTemplate, EditConst, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bInterpMovement : 1;                               // 0x0119(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bInterpRotation : 1;                               // 0x0119(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bThrottleInterpolation : 1;                        // 0x0119(0x0001)(BitIndex: 0x04, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         BitPad_119_5 : 3;                                  // 0x0119(0x0001)(Fixing Bit-Field Size For New Byte [ Dumper-7 ])
	uint8                                         Pad_11A[0x6];                                      // 0x011A(0x0006)(Fixing Size After Last Property [ Dumper-7 ])
	uint8                                         bInterpolationUseScopedMovement : 1;               // 0x0120(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_121[0x3];                                      // 0x0121(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         PreviousHitTime;                                   // 0x0124(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, DisableEditOnTemplate, EditConst, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector                                PreviousHitNormal;                                 // 0x0128(0x0018)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, DisableEditOnTemplate, EditConst, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         ProjectileGravityScale;                            // 0x0140(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         Buoyancy;                                          // 0x0144(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         Bounciness;                                        // 0x0148(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         Friction;                                          // 0x014C(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         BounceVelocityStopSimulatingThreshold;             // 0x0150(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         MinFrictionFraction;                               // 0x0154(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TMulticastInlineDelegate<void(const struct FHitResult& ImpactResult, const struct FVector& ImpactVelocity)> OnProjectileBounce; // 0x0158(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	TMulticastInlineDelegate<void(const struct FHitResult& ImpactResult)> OnProjectileStop;          // 0x0168(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	float                                         HomingAccelerationMagnitude;                       // 0x0178(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TWeakObjectPtr<class USceneComponent>         HomingTargetComponent;                             // 0x017C(0x0008)(Edit, BlueprintVisible, ExportObject, ZeroConstructor, DisableEditOnTemplate, EditConst, InstancedReference, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         MaxSimulationTimeStep;                             // 0x0184(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         MaxSimulationIterations;                           // 0x0188(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         BounceAdditionalIterations;                        // 0x018C(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         InterpLocationTime;                                // 0x0190(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         InterpRotationTime;                                // 0x0194(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         InterpLocationMaxLagDistance;                      // 0x0198(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         InterpLocationSnapToTargetDistance;                // 0x019C(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         ThrottleInterpolationThresholdNotRenderedShortTime; // 0x01A0(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         ThrottleInterpolationThresholdNotRenderedLongTime; // 0x01A4(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         ThrottleInterpolationSkipFramesRecent;             // 0x01A8(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         ThrottleInterpolationSkipFramesNotRecent;          // 0x01AC(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1B0[0xB0];                                     // 0x01B0(0x00B0)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void MoveInterpolationTarget(const struct FVector& NewLocation, const struct FRotator& NewRotation);
	void ResetInterpolation();
	void SetInterpolatedComponent(class USceneComponent* Component);
	void SetVelocityInLocalSpace(const struct FVector& NewVelocity);
	void StopSimulating(const struct FHitResult& HitResult);

	bool IsInterpolationComplete() const;
	bool IsVelocityUnderSimulationThreshold() const;
	struct FVector LimitVelocity(const struct FVector& NewVelocity) const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ProjectileMovementComponent">();
	}
	static class UProjectileMovementComponent* GetDefaultObj()
	{
		return GetDefaultObjImpl<UProjectileMovementComponent>();
	}
};
static_assert(alignof(UProjectileMovementComponent) == 0x000010, "Wrong alignment on UProjectileMovementComponent");
static_assert(sizeof(UProjectileMovementComponent) == 0x000260, "Wrong size on UProjectileMovementComponent");
static_assert(offsetof(UProjectileMovementComponent, InitialSpeed) == 0x000110, "Member 'UProjectileMovementComponent::InitialSpeed' has a wrong offset!");
static_assert(offsetof(UProjectileMovementComponent, MaxSpeed) == 0x000114, "Member 'UProjectileMovementComponent::MaxSpeed' has a wrong offset!");
static_assert(offsetof(UProjectileMovementComponent, PreviousHitTime) == 0x000124, "Member 'UProjectileMovementComponent::PreviousHitTime' has a wrong offset!");
static_assert(offsetof(UProjectileMovementComponent, PreviousHitNormal) == 0x000128, "Member 'UProjectileMovementComponent::PreviousHitNormal' has a wrong offset!");
static_assert(offsetof(UProjectileMovementComponent, ProjectileGravityScale) == 0x000140, "Member 'UProjectileMovementComponent::ProjectileGravityScale' has a wrong offset!");
static_assert(offsetof(UProjectileMovementComponent, Buoyancy) == 0x000144, "Member 'UProjectileMovementComponent::Buoyancy' has a wrong offset!");
static_assert(offsetof(UProjectileMovementComponent, Bounciness) == 0x000148, "Member 'UProjectileMovementComponent::Bounciness' has a wrong offset!");
static_assert(offsetof(UProjectileMovementComponent, Friction) == 0x00014C, "Member 'UProjectileMovementComponent::Friction' has a wrong offset!");
static_assert(offsetof(UProjectileMovementComponent, BounceVelocityStopSimulatingThreshold) == 0x000150, "Member 'UProjectileMovementComponent::BounceVelocityStopSimulatingThreshold' has a wrong offset!");
static_assert(offsetof(UProjectileMovementComponent, MinFrictionFraction) == 0x000154, "Member 'UProjectileMovementComponent::MinFrictionFraction' has a wrong offset!");
static_assert(offsetof(UProjectileMovementComponent, OnProjectileBounce) == 0x000158, "Member 'UProjectileMovementComponent::OnProjectileBounce' has a wrong offset!");
static_assert(offsetof(UProjectileMovementComponent, OnProjectileStop) == 0x000168, "Member 'UProjectileMovementComponent::OnProjectileStop' has a wrong offset!");
static_assert(offsetof(UProjectileMovementComponent, HomingAccelerationMagnitude) == 0x000178, "Member 'UProjectileMovementComponent::HomingAccelerationMagnitude' has a wrong offset!");
static_assert(offsetof(UProjectileMovementComponent, HomingTargetComponent) == 0x00017C, "Member 'UProjectileMovementComponent::HomingTargetComponent' has a wrong offset!");
static_assert(offsetof(UProjectileMovementComponent, MaxSimulationTimeStep) == 0x000184, "Member 'UProjectileMovementComponent::MaxSimulationTimeStep' has a wrong offset!");
static_assert(offsetof(UProjectileMovementComponent, MaxSimulationIterations) == 0x000188, "Member 'UProjectileMovementComponent::MaxSimulationIterations' has a wrong offset!");
static_assert(offsetof(UProjectileMovementComponent, BounceAdditionalIterations) == 0x00018C, "Member 'UProjectileMovementComponent::BounceAdditionalIterations' has a wrong offset!");
static_assert(offsetof(UProjectileMovementComponent, InterpLocationTime) == 0x000190, "Member 'UProjectileMovementComponent::InterpLocationTime' has a wrong offset!");
static_assert(offsetof(UProjectileMovementComponent, InterpRotationTime) == 0x000194, "Member 'UProjectileMovementComponent::InterpRotationTime' has a wrong offset!");
static_assert(offsetof(UProjectileMovementComponent, InterpLocationMaxLagDistance) == 0x000198, "Member 'UProjectileMovementComponent::InterpLocationMaxLagDistance' has a wrong offset!");
static_assert(offsetof(UProjectileMovementComponent, InterpLocationSnapToTargetDistance) == 0x00019C, "Member 'UProjectileMovementComponent::InterpLocationSnapToTargetDistance' has a wrong offset!");
static_assert(offsetof(UProjectileMovementComponent, ThrottleInterpolationThresholdNotRenderedShortTime) == 0x0001A0, "Member 'UProjectileMovementComponent::ThrottleInterpolationThresholdNotRenderedShortTime' has a wrong offset!");
static_assert(offsetof(UProjectileMovementComponent, ThrottleInterpolationThresholdNotRenderedLongTime) == 0x0001A4, "Member 'UProjectileMovementComponent::ThrottleInterpolationThresholdNotRenderedLongTime' has a wrong offset!");
static_assert(offsetof(UProjectileMovementComponent, ThrottleInterpolationSkipFramesRecent) == 0x0001A8, "Member 'UProjectileMovementComponent::ThrottleInterpolationSkipFramesRecent' has a wrong offset!");
static_assert(offsetof(UProjectileMovementComponent, ThrottleInterpolationSkipFramesNotRecent) == 0x0001AC, "Member 'UProjectileMovementComponent::ThrottleInterpolationSkipFramesNotRecent' has a wrong offset!");

// Class Engine.RectLightComponent
// 0x0020 (0x0430 - 0x0410)
class URectLightComponent final : public ULocalLightComponent
{
public:
	float                                         SourceWidth;                                       // 0x0410(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         SourceHeight;                                      // 0x0414(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         BarnDoorAngle;                                     // 0x0418(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         BarnDoorLength;                                    // 0x041C(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UTexture*                               SourceTexture;                                     // 0x0420(0x0008)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_428[0x8];                                      // 0x0428(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void SetBarnDoorAngle(float NewValue);
	void SetBarnDoorLength(float NewValue);
	void SetSourceHeight(float NewValue);
	void SetSourceTexture(class UTexture* NewValue);
	void SetSourceWidth(float NewValue);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"RectLightComponent">();
	}
	static class URectLightComponent* GetDefaultObj()
	{
		return GetDefaultObjImpl<URectLightComponent>();
	}
};
static_assert(alignof(URectLightComponent) == 0x000010, "Wrong alignment on URectLightComponent");
static_assert(sizeof(URectLightComponent) == 0x000430, "Wrong size on URectLightComponent");
static_assert(offsetof(URectLightComponent, SourceWidth) == 0x000410, "Member 'URectLightComponent::SourceWidth' has a wrong offset!");
static_assert(offsetof(URectLightComponent, SourceHeight) == 0x000414, "Member 'URectLightComponent::SourceHeight' has a wrong offset!");
static_assert(offsetof(URectLightComponent, BarnDoorAngle) == 0x000418, "Member 'URectLightComponent::BarnDoorAngle' has a wrong offset!");
static_assert(offsetof(URectLightComponent, BarnDoorLength) == 0x00041C, "Member 'URectLightComponent::BarnDoorLength' has a wrong offset!");
static_assert(offsetof(URectLightComponent, SourceTexture) == 0x000420, "Member 'URectLightComponent::SourceTexture' has a wrong offset!");

// Class Engine.RuntimeVirtualTextureComponent
// 0x0090 (0x0330 - 0x02A0)
class URuntimeVirtualTextureComponent final : public USceneComponent
{
public:
	TSoftObjectPtr<class AActor>                  BoundsAlignActor;                                  // 0x02A0(0x0028)(Edit, Protected, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	bool                                          bSetBoundsButton;                                  // 0x02C8(0x0001)(Edit, ZeroConstructor, Transient, EditConst, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	bool                                          bSnapBoundsToLandscape;                            // 0x02C9(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_2CA[0x6];                                      // 0x02CA(0x0006)(Fixing Size After Last Property [ Dumper-7 ])
	class URuntimeVirtualTexture*                 VirtualTexture;                                    // 0x02D0(0x0008)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, NoDestructor, Protected, TextExportTransient, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	bool                                          bEnableScalability;                                // 0x02D8(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_2D9[0x3];                                      // 0x02D9(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	uint32                                        ScalabilityGroup;                                  // 0x02DC(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	bool                                          bHidePrimitives;                                   // 0x02E0(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_2E1[0x7];                                      // 0x02E1(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	class UVirtualTextureBuilder*                 StreamingTexture;                                  // 0x02E8(0x0008)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, NoDestructor, Protected, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	int32                                         StreamLowMips;                                     // 0x02F0(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	bool                                          bBuildStreamingMipsButton;                         // 0x02F4(0x0001)(Edit, ZeroConstructor, Transient, EditConst, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	ETextureLossyCompressionAmount                LossyCompressionAmount;                            // 0x02F5(0x0001)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	bool                                          bUseStreamingLowMipsInEditor;                      // 0x02F6(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	bool                                          bBuildDebugStreamingMips;                          // 0x02F7(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, Transient, IsPlainOldData, NoDestructor, AdvancedDisplay, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_2F8[0x38];                                     // 0x02F8(0x0038)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void Invalidate(const struct FBoxSphereBounds& WorldBounds);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"RuntimeVirtualTextureComponent">();
	}
	static class URuntimeVirtualTextureComponent* GetDefaultObj()
	{
		return GetDefaultObjImpl<URuntimeVirtualTextureComponent>();
	}
};
static_assert(alignof(URuntimeVirtualTextureComponent) == 0x000010, "Wrong alignment on URuntimeVirtualTextureComponent");
static_assert(sizeof(URuntimeVirtualTextureComponent) == 0x000330, "Wrong size on URuntimeVirtualTextureComponent");
static_assert(offsetof(URuntimeVirtualTextureComponent, BoundsAlignActor) == 0x0002A0, "Member 'URuntimeVirtualTextureComponent::BoundsAlignActor' has a wrong offset!");
static_assert(offsetof(URuntimeVirtualTextureComponent, bSetBoundsButton) == 0x0002C8, "Member 'URuntimeVirtualTextureComponent::bSetBoundsButton' has a wrong offset!");
static_assert(offsetof(URuntimeVirtualTextureComponent, bSnapBoundsToLandscape) == 0x0002C9, "Member 'URuntimeVirtualTextureComponent::bSnapBoundsToLandscape' has a wrong offset!");
static_assert(offsetof(URuntimeVirtualTextureComponent, VirtualTexture) == 0x0002D0, "Member 'URuntimeVirtualTextureComponent::VirtualTexture' has a wrong offset!");
static_assert(offsetof(URuntimeVirtualTextureComponent, bEnableScalability) == 0x0002D8, "Member 'URuntimeVirtualTextureComponent::bEnableScalability' has a wrong offset!");
static_assert(offsetof(URuntimeVirtualTextureComponent, ScalabilityGroup) == 0x0002DC, "Member 'URuntimeVirtualTextureComponent::ScalabilityGroup' has a wrong offset!");
static_assert(offsetof(URuntimeVirtualTextureComponent, bHidePrimitives) == 0x0002E0, "Member 'URuntimeVirtualTextureComponent::bHidePrimitives' has a wrong offset!");
static_assert(offsetof(URuntimeVirtualTextureComponent, StreamingTexture) == 0x0002E8, "Member 'URuntimeVirtualTextureComponent::StreamingTexture' has a wrong offset!");
static_assert(offsetof(URuntimeVirtualTextureComponent, StreamLowMips) == 0x0002F0, "Member 'URuntimeVirtualTextureComponent::StreamLowMips' has a wrong offset!");
static_assert(offsetof(URuntimeVirtualTextureComponent, bBuildStreamingMipsButton) == 0x0002F4, "Member 'URuntimeVirtualTextureComponent::bBuildStreamingMipsButton' has a wrong offset!");
static_assert(offsetof(URuntimeVirtualTextureComponent, LossyCompressionAmount) == 0x0002F5, "Member 'URuntimeVirtualTextureComponent::LossyCompressionAmount' has a wrong offset!");
static_assert(offsetof(URuntimeVirtualTextureComponent, bUseStreamingLowMipsInEditor) == 0x0002F6, "Member 'URuntimeVirtualTextureComponent::bUseStreamingLowMipsInEditor' has a wrong offset!");
static_assert(offsetof(URuntimeVirtualTextureComponent, bBuildDebugStreamingMips) == 0x0002F7, "Member 'URuntimeVirtualTextureComponent::bBuildDebugStreamingMips' has a wrong offset!");

// Class Engine.SkyAtmosphere
// 0x0008 (0x02A8 - 0x02A0)
class ASkyAtmosphere final : public AInfo
{
public:
	class USkyAtmosphereComponent*                SkyAtmosphereComponent;                            // 0x02A0(0x0008)(Edit, BlueprintVisible, ExportObject, BlueprintReadOnly, ZeroConstructor, EditConst, InstancedReference, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"SkyAtmosphere">();
	}
	static class ASkyAtmosphere* GetDefaultObj()
	{
		return GetDefaultObjImpl<ASkyAtmosphere>();
	}
};
static_assert(alignof(ASkyAtmosphere) == 0x000008, "Wrong alignment on ASkyAtmosphere");
static_assert(sizeof(ASkyAtmosphere) == 0x0002A8, "Wrong size on ASkyAtmosphere");
static_assert(offsetof(ASkyAtmosphere, SkyAtmosphereComponent) == 0x0002A0, "Member 'ASkyAtmosphere::SkyAtmosphereComponent' has a wrong offset!");

// Class Engine.SplineMeshComponent
// 0x0100 (0x0740 - 0x0640)
class USplineMeshComponent final : public UStaticMeshComponent
{
public:
	uint8                                         Pad_640[0x8];                                      // 0x0640(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	struct FSplineMeshParams                      SplineParams;                                      // 0x0648(0x00B0)(Edit, NoDestructor, NativeAccessSpecifierPublic)
	struct FVector                                SplineUpDir;                                       // 0x06F8(0x0018)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         SplineBoundaryMin;                                 // 0x0710(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FGuid                                  CachedMeshBodySetupGuid;                           // 0x0714(0x0010)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_724[0x4];                                      // 0x0724(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	class UBodySetup*                             BodySetup;                                         // 0x0728(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         SplineBoundaryMax;                                 // 0x0730(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bAllowSplineEditingPerInstance : 1;                // 0x0734(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, DisableEditOnInstance, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bSmoothInterpRollScale : 1;                        // 0x0734(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bMeshDirty : 1;                                    // 0x0734(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Transient, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	ESplineMeshAxis                               ForwardAxis;                                       // 0x0735(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_736[0x2];                                      // 0x0736(0x0002)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         VirtualTextureMainPassMaxDrawDistance;             // 0x0738(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bNeverNeedsCookedCollisionData : 1;                // 0x073C(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate))
	uint8                                         Pad_73D[0x3];                                      // 0x073D(0x0003)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void SetBoundaryMax(float InBoundaryMax, bool bUpdateMesh);
	void SetBoundaryMin(float InBoundaryMin, bool bUpdateMesh);
	void SetEndOffset(const struct FVector2D& EndOffset, bool bUpdateMesh);
	void SetEndPosition(const struct FVector& EndPos, bool bUpdateMesh);
	void SetEndRoll(float EndRoll, bool bUpdateMesh);
	void SetEndRollDegrees(float EndRollDegrees, bool bUpdateMesh);
	void SetEndScale(const struct FVector2D& EndScale, bool bUpdateMesh);
	void SetEndTangent(const struct FVector& EndTangent, bool bUpdateMesh);
	void SetForwardAxis(ESplineMeshAxis InForwardAxis, bool bUpdateMesh);
	void SetSplineUpDir(const struct FVector& InSplineUpDir, bool bUpdateMesh);
	void SetStartAndEnd(const struct FVector& StartPos, const struct FVector& StartTangent, const struct FVector& EndPos, const struct FVector& EndTangent, bool bUpdateMesh);
	void SetStartOffset(const struct FVector2D& StartOffset, bool bUpdateMesh);
	void SetStartPosition(const struct FVector& StartPos, bool bUpdateMesh);
	void SetStartRoll(float StartRoll, bool bUpdateMesh);
	void SetStartRollDegrees(float StartRollDegrees, bool bUpdateMesh);
	void SetStartScale(const struct FVector2D& StartScale, bool bUpdateMesh);
	void SetStartTangent(const struct FVector& StartTangent, bool bUpdateMesh);
	void UpdateMesh();

	float GetBoundaryMax() const;
	float GetBoundaryMin() const;
	struct FVector2D GetEndOffset() const;
	struct FVector GetEndPosition() const;
	float GetEndRoll() const;
	struct FVector2D GetEndScale() const;
	struct FVector GetEndTangent() const;
	ESplineMeshAxis GetForwardAxis() const;
	struct FVector GetSplineUpDir() const;
	struct FVector2D GetStartOffset() const;
	struct FVector GetStartPosition() const;
	float GetStartRoll() const;
	struct FVector2D GetStartScale() const;
	struct FVector GetStartTangent() const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"SplineMeshComponent">();
	}
	static class USplineMeshComponent* GetDefaultObj()
	{
		return GetDefaultObjImpl<USplineMeshComponent>();
	}
};
static_assert(alignof(USplineMeshComponent) == 0x000010, "Wrong alignment on USplineMeshComponent");
static_assert(sizeof(USplineMeshComponent) == 0x000740, "Wrong size on USplineMeshComponent");
static_assert(offsetof(USplineMeshComponent, SplineParams) == 0x000648, "Member 'USplineMeshComponent::SplineParams' has a wrong offset!");
static_assert(offsetof(USplineMeshComponent, SplineUpDir) == 0x0006F8, "Member 'USplineMeshComponent::SplineUpDir' has a wrong offset!");
static_assert(offsetof(USplineMeshComponent, SplineBoundaryMin) == 0x000710, "Member 'USplineMeshComponent::SplineBoundaryMin' has a wrong offset!");
static_assert(offsetof(USplineMeshComponent, CachedMeshBodySetupGuid) == 0x000714, "Member 'USplineMeshComponent::CachedMeshBodySetupGuid' has a wrong offset!");
static_assert(offsetof(USplineMeshComponent, BodySetup) == 0x000728, "Member 'USplineMeshComponent::BodySetup' has a wrong offset!");
static_assert(offsetof(USplineMeshComponent, SplineBoundaryMax) == 0x000730, "Member 'USplineMeshComponent::SplineBoundaryMax' has a wrong offset!");
static_assert(offsetof(USplineMeshComponent, ForwardAxis) == 0x000735, "Member 'USplineMeshComponent::ForwardAxis' has a wrong offset!");
static_assert(offsetof(USplineMeshComponent, VirtualTextureMainPassMaxDrawDistance) == 0x000738, "Member 'USplineMeshComponent::VirtualTextureMainPassMaxDrawDistance' has a wrong offset!");

// Class Engine.SpotLightComponent
// 0x0000 (0x0430 - 0x0430)
class USpotLightComponent final : public UPointLightComponent
{
public:
	float                                         InnerConeAngle;                                    // 0x0428(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         OuterConeAngle;                                    // 0x042C(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

public:
	void SetInnerConeAngle(float NewInnerConeAngle);
	void SetOuterConeAngle(float NewOuterConeAngle);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"SpotLightComponent">();
	}
	static class USpotLightComponent* GetDefaultObj()
	{
		return GetDefaultObjImpl<USpotLightComponent>();
	}
};
static_assert(alignof(USpotLightComponent) == 0x000010, "Wrong alignment on USpotLightComponent");
static_assert(sizeof(USpotLightComponent) == 0x000430, "Wrong size on USpotLightComponent");
static_assert(offsetof(USpotLightComponent, InnerConeAngle) == 0x000428, "Member 'USpotLightComponent::InnerConeAngle' has a wrong offset!");
static_assert(offsetof(USpotLightComponent, OuterConeAngle) == 0x00042C, "Member 'USpotLightComponent::OuterConeAngle' has a wrong offset!");

// Class Engine.VolumetricCloudComponent
// 0x0070 (0x0310 - 0x02A0)
class UVolumetricCloudComponent final : public USceneComponent
{
public:
	float                                         LayerBottomAltitude;                               // 0x02A0(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         LayerHeight;                                       // 0x02A4(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         TracingStartMaxDistance;                           // 0x02A8(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EVolumetricCloudTracingMaxDistanceMode        TracingMaxDistanceMode;                            // 0x02AC(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_2AD[0x3];                                      // 0x02AD(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         TracingMaxDistance;                                // 0x02B0(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         PlanetRadius;                                      // 0x02B4(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FColor                                 GroundAlbedo;                                      // 0x02B8(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_2BC[0x4];                                      // 0x02BC(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	class UMaterialInterface*                     Material;                                          // 0x02C0(0x0008)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bUsePerSampleAtmosphericLightTransmittance : 1;    // 0x02C8(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_2C9[0x3];                                      // 0x02C9(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         SkyLightCloudBottomOcclusion;                      // 0x02CC(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         ViewSampleCountScale;                              // 0x02D0(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         ReflectionViewSampleCountScaleValue;               // 0x02D4(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         ReflectionViewSampleCountScale;                    // 0x02D8(0x0004)(ZeroConstructor, Deprecated, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         ReflectionSampleCountScale;                        // 0x02DC(0x0004)(ZeroConstructor, Deprecated, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         ShadowViewSampleCountScale;                        // 0x02E0(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         ShadowReflectionViewSampleCountScaleValue;         // 0x02E4(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         ShadowReflectionViewSampleCountScale;              // 0x02E8(0x0004)(ZeroConstructor, Deprecated, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         ShadowReflectionSampleCountScale;                  // 0x02EC(0x0004)(ZeroConstructor, Deprecated, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         ShadowTracingDistance;                             // 0x02F0(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         StopTracingTransmittanceThreshold;                 // 0x02F4(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         AerialPespectiveRayleighScatteringStartDistance;   // 0x02F8(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         AerialPespectiveRayleighScatteringFadeDistance;    // 0x02FC(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         AerialPespectiveMieScatteringStartDistance;        // 0x0300(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         AerialPespectiveMieScatteringFadeDistance;         // 0x0304(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_308[0x8];                                      // 0x0308(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void SetbUsePerSampleAtmosphericLightTransmittance(bool NewValue);
	void SetGroundAlbedo(const struct FColor& NewValue);
	void SetLayerBottomAltitude(float NewValue);
	void SetLayerHeight(float NewValue);
	void SetMaterial(class UMaterialInterface* NewValue);
	void SetPlanetRadius(float NewValue);
	void SetReflectionSampleCountScale(float NewValue);
	void SetReflectionViewSampleCountScale(float NewValue);
	void SetShadowReflectionSampleCountScale(float NewValue);
	void SetShadowReflectionViewSampleCountScale(float NewValue);
	void SetShadowTracingDistance(float NewValue);
	void SetShadowViewSampleCountScale(float NewValue);
	void SetSkyLightCloudBottomOcclusion(float NewValue);
	void SetStopTracingTransmittanceThreshold(float NewValue);
	void SetTracingMaxDistance(float NewValue);
	void SetTracingStartMaxDistance(float NewValue);
	void SetViewSampleCountScale(float NewValue);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"VolumetricCloudComponent">();
	}
	static class UVolumetricCloudComponent* GetDefaultObj()
	{
		return GetDefaultObjImpl<UVolumetricCloudComponent>();
	}
};
static_assert(alignof(UVolumetricCloudComponent) == 0x000010, "Wrong alignment on UVolumetricCloudComponent");
static_assert(sizeof(UVolumetricCloudComponent) == 0x000310, "Wrong size on UVolumetricCloudComponent");
static_assert(offsetof(UVolumetricCloudComponent, LayerBottomAltitude) == 0x0002A0, "Member 'UVolumetricCloudComponent::LayerBottomAltitude' has a wrong offset!");
static_assert(offsetof(UVolumetricCloudComponent, LayerHeight) == 0x0002A4, "Member 'UVolumetricCloudComponent::LayerHeight' has a wrong offset!");
static_assert(offsetof(UVolumetricCloudComponent, TracingStartMaxDistance) == 0x0002A8, "Member 'UVolumetricCloudComponent::TracingStartMaxDistance' has a wrong offset!");
static_assert(offsetof(UVolumetricCloudComponent, TracingMaxDistanceMode) == 0x0002AC, "Member 'UVolumetricCloudComponent::TracingMaxDistanceMode' has a wrong offset!");
static_assert(offsetof(UVolumetricCloudComponent, TracingMaxDistance) == 0x0002B0, "Member 'UVolumetricCloudComponent::TracingMaxDistance' has a wrong offset!");
static_assert(offsetof(UVolumetricCloudComponent, PlanetRadius) == 0x0002B4, "Member 'UVolumetricCloudComponent::PlanetRadius' has a wrong offset!");
static_assert(offsetof(UVolumetricCloudComponent, GroundAlbedo) == 0x0002B8, "Member 'UVolumetricCloudComponent::GroundAlbedo' has a wrong offset!");
static_assert(offsetof(UVolumetricCloudComponent, Material) == 0x0002C0, "Member 'UVolumetricCloudComponent::Material' has a wrong offset!");
static_assert(offsetof(UVolumetricCloudComponent, SkyLightCloudBottomOcclusion) == 0x0002CC, "Member 'UVolumetricCloudComponent::SkyLightCloudBottomOcclusion' has a wrong offset!");
static_assert(offsetof(UVolumetricCloudComponent, ViewSampleCountScale) == 0x0002D0, "Member 'UVolumetricCloudComponent::ViewSampleCountScale' has a wrong offset!");
static_assert(offsetof(UVolumetricCloudComponent, ReflectionViewSampleCountScaleValue) == 0x0002D4, "Member 'UVolumetricCloudComponent::ReflectionViewSampleCountScaleValue' has a wrong offset!");
static_assert(offsetof(UVolumetricCloudComponent, ReflectionViewSampleCountScale) == 0x0002D8, "Member 'UVolumetricCloudComponent::ReflectionViewSampleCountScale' has a wrong offset!");
static_assert(offsetof(UVolumetricCloudComponent, ReflectionSampleCountScale) == 0x0002DC, "Member 'UVolumetricCloudComponent::ReflectionSampleCountScale' has a wrong offset!");
static_assert(offsetof(UVolumetricCloudComponent, ShadowViewSampleCountScale) == 0x0002E0, "Member 'UVolumetricCloudComponent::ShadowViewSampleCountScale' has a wrong offset!");
static_assert(offsetof(UVolumetricCloudComponent, ShadowReflectionViewSampleCountScaleValue) == 0x0002E4, "Member 'UVolumetricCloudComponent::ShadowReflectionViewSampleCountScaleValue' has a wrong offset!");
static_assert(offsetof(UVolumetricCloudComponent, ShadowReflectionViewSampleCountScale) == 0x0002E8, "Member 'UVolumetricCloudComponent::ShadowReflectionViewSampleCountScale' has a wrong offset!");
static_assert(offsetof(UVolumetricCloudComponent, ShadowReflectionSampleCountScale) == 0x0002EC, "Member 'UVolumetricCloudComponent::ShadowReflectionSampleCountScale' has a wrong offset!");
static_assert(offsetof(UVolumetricCloudComponent, ShadowTracingDistance) == 0x0002F0, "Member 'UVolumetricCloudComponent::ShadowTracingDistance' has a wrong offset!");
static_assert(offsetof(UVolumetricCloudComponent, StopTracingTransmittanceThreshold) == 0x0002F4, "Member 'UVolumetricCloudComponent::StopTracingTransmittanceThreshold' has a wrong offset!");
static_assert(offsetof(UVolumetricCloudComponent, AerialPespectiveRayleighScatteringStartDistance) == 0x0002F8, "Member 'UVolumetricCloudComponent::AerialPespectiveRayleighScatteringStartDistance' has a wrong offset!");
static_assert(offsetof(UVolumetricCloudComponent, AerialPespectiveRayleighScatteringFadeDistance) == 0x0002FC, "Member 'UVolumetricCloudComponent::AerialPespectiveRayleighScatteringFadeDistance' has a wrong offset!");
static_assert(offsetof(UVolumetricCloudComponent, AerialPespectiveMieScatteringStartDistance) == 0x000300, "Member 'UVolumetricCloudComponent::AerialPespectiveMieScatteringStartDistance' has a wrong offset!");
static_assert(offsetof(UVolumetricCloudComponent, AerialPespectiveMieScatteringFadeDistance) == 0x000304, "Member 'UVolumetricCloudComponent::AerialPespectiveMieScatteringFadeDistance' has a wrong offset!");

// Class Engine.WorldPartitionStreamingSourceComponent
// 0x0060 (0x0108 - 0x00A8)
class UWorldPartitionStreamingSourceComponent final : public UActorComponent
{
public:
	uint8                                         Pad_A8[0x8];                                       // 0x00A8(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	EStreamingSourceTargetBehavior                TargetBehavior;                                    // 0x00B0(0x0001)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_B1[0x7];                                       // 0x00B1(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<class FName>                           TargetGrids;                                       // 0x00B8(0x0010)(Edit, BlueprintVisible, ZeroConstructor, NativeAccessSpecifierPublic)
	class FName                                   TargetGrid;                                        // 0x00C8(0x0008)(ZeroConstructor, Deprecated, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FColor                                 DebugColor;                                        // 0x00D0(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_D4[0x4];                                       // 0x00D4(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<class UHLODLayer*>                     TargetHLODLayers;                                  // 0x00D8(0x0010)(Edit, BlueprintVisible, ZeroConstructor, UObjectWrapper, NativeAccessSpecifierPublic)
	class UHLODLayer*                             TargetHLODLayer;                                   // 0x00E8(0x0008)(ZeroConstructor, Deprecated, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TArray<struct FStreamingSourceShape>          Shapes;                                            // 0x00F0(0x0010)(Edit, BlueprintVisible, ZeroConstructor, NativeAccessSpecifierPublic)
	EStreamingSourcePriority                      Priority;                                          // 0x0100(0x0001)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bStreamingSourceEnabled;                           // 0x0101(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	EStreamingSourceTargetState                   TargetState;                                       // 0x0102(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_103[0x5];                                      // 0x0103(0x0005)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void DisableStreamingSource();
	void EnableStreamingSource();

	bool IsStreamingCompleted() const;
	bool IsStreamingSourceEnabled() const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"WorldPartitionStreamingSourceComponent">();
	}
	static class UWorldPartitionStreamingSourceComponent* GetDefaultObj()
	{
		return GetDefaultObjImpl<UWorldPartitionStreamingSourceComponent>();
	}
};
static_assert(alignof(UWorldPartitionStreamingSourceComponent) == 0x000008, "Wrong alignment on UWorldPartitionStreamingSourceComponent");
static_assert(sizeof(UWorldPartitionStreamingSourceComponent) == 0x000108, "Wrong size on UWorldPartitionStreamingSourceComponent");
static_assert(offsetof(UWorldPartitionStreamingSourceComponent, TargetBehavior) == 0x0000B0, "Member 'UWorldPartitionStreamingSourceComponent::TargetBehavior' has a wrong offset!");
static_assert(offsetof(UWorldPartitionStreamingSourceComponent, TargetGrids) == 0x0000B8, "Member 'UWorldPartitionStreamingSourceComponent::TargetGrids' has a wrong offset!");
static_assert(offsetof(UWorldPartitionStreamingSourceComponent, TargetGrid) == 0x0000C8, "Member 'UWorldPartitionStreamingSourceComponent::TargetGrid' has a wrong offset!");
static_assert(offsetof(UWorldPartitionStreamingSourceComponent, DebugColor) == 0x0000D0, "Member 'UWorldPartitionStreamingSourceComponent::DebugColor' has a wrong offset!");
static_assert(offsetof(UWorldPartitionStreamingSourceComponent, TargetHLODLayers) == 0x0000D8, "Member 'UWorldPartitionStreamingSourceComponent::TargetHLODLayers' has a wrong offset!");
static_assert(offsetof(UWorldPartitionStreamingSourceComponent, TargetHLODLayer) == 0x0000E8, "Member 'UWorldPartitionStreamingSourceComponent::TargetHLODLayer' has a wrong offset!");
static_assert(offsetof(UWorldPartitionStreamingSourceComponent, Shapes) == 0x0000F0, "Member 'UWorldPartitionStreamingSourceComponent::Shapes' has a wrong offset!");
static_assert(offsetof(UWorldPartitionStreamingSourceComponent, Priority) == 0x000100, "Member 'UWorldPartitionStreamingSourceComponent::Priority' has a wrong offset!");
static_assert(offsetof(UWorldPartitionStreamingSourceComponent, bStreamingSourceEnabled) == 0x000101, "Member 'UWorldPartitionStreamingSourceComponent::bStreamingSourceEnabled' has a wrong offset!");
static_assert(offsetof(UWorldPartitionStreamingSourceComponent, TargetState) == 0x000102, "Member 'UWorldPartitionStreamingSourceComponent::TargetState' has a wrong offset!");

// Class Engine.CurveTable
// 0x0078 (0x00A0 - 0x0028)
class UCurveTable : public UObject
{
public:
	uint8                                         Pad_28[0x78];                                      // 0x0028(0x0078)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"CurveTable">();
	}
	static class UCurveTable* GetDefaultObj()
	{
		return GetDefaultObjImpl<UCurveTable>();
	}
};
static_assert(alignof(UCurveTable) == 0x000008, "Wrong alignment on UCurveTable");
static_assert(sizeof(UCurveTable) == 0x0000A0, "Wrong size on UCurveTable");

// Class Engine.CompositeCurveTable
// 0x0028 (0x00C8 - 0x00A0)
class UCompositeCurveTable final : public UCurveTable
{
public:
	TArray<class UCurveTable*>                    ParentTables;                                      // 0x00A0(0x0010)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, Protected, UObjectWrapper, NativeAccessSpecifierProtected)
	TArray<class UCurveTable*>                    OldParentTables;                                   // 0x00B0(0x0010)(ZeroConstructor, Transient, Protected, UObjectWrapper, NativeAccessSpecifierProtected)
	uint8                                         Pad_C0[0x8];                                       // 0x00C0(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"CompositeCurveTable">();
	}
	static class UCompositeCurveTable* GetDefaultObj()
	{
		return GetDefaultObjImpl<UCompositeCurveTable>();
	}
};
static_assert(alignof(UCompositeCurveTable) == 0x000008, "Wrong alignment on UCompositeCurveTable");
static_assert(sizeof(UCompositeCurveTable) == 0x0000C8, "Wrong size on UCompositeCurveTable");
static_assert(offsetof(UCompositeCurveTable, ParentTables) == 0x0000A0, "Member 'UCompositeCurveTable::ParentTables' has a wrong offset!");
static_assert(offsetof(UCompositeCurveTable, OldParentTables) == 0x0000B0, "Member 'UCompositeCurveTable::OldParentTables' has a wrong offset!");

// Class Engine.EnumCookedMetaData
// 0x0050 (0x0078 - 0x0028)
class UEnumCookedMetaData final : public UObject
{
public:
	struct FObjectCookedMetaDataStore             EnumMetaData;                                      // 0x0028(0x0050)(Protected, NativeAccessSpecifierProtected)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"EnumCookedMetaData">();
	}
	static class UEnumCookedMetaData* GetDefaultObj()
	{
		return GetDefaultObjImpl<UEnumCookedMetaData>();
	}
};
static_assert(alignof(UEnumCookedMetaData) == 0x000008, "Wrong alignment on UEnumCookedMetaData");
static_assert(sizeof(UEnumCookedMetaData) == 0x000078, "Wrong size on UEnumCookedMetaData");
static_assert(offsetof(UEnumCookedMetaData, EnumMetaData) == 0x000028, "Member 'UEnumCookedMetaData::EnumMetaData' has a wrong offset!");

// Class Engine.StructCookedMetaData
// 0x00A0 (0x00C8 - 0x0028)
class UStructCookedMetaData final : public UObject
{
public:
	struct FStructCookedMetaDataStore             StructMetaData;                                    // 0x0028(0x00A0)(Protected, NativeAccessSpecifierProtected)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"StructCookedMetaData">();
	}
	static class UStructCookedMetaData* GetDefaultObj()
	{
		return GetDefaultObjImpl<UStructCookedMetaData>();
	}
};
static_assert(alignof(UStructCookedMetaData) == 0x000008, "Wrong alignment on UStructCookedMetaData");
static_assert(sizeof(UStructCookedMetaData) == 0x0000C8, "Wrong size on UStructCookedMetaData");
static_assert(offsetof(UStructCookedMetaData, StructMetaData) == 0x000028, "Member 'UStructCookedMetaData::StructMetaData' has a wrong offset!");

// Class Engine.ClassCookedMetaData
// 0x00F0 (0x0118 - 0x0028)
class UClassCookedMetaData final : public UObject
{
public:
	struct FStructCookedMetaDataStore             ClassMetaData;                                     // 0x0028(0x00A0)(Protected, NativeAccessSpecifierProtected)
	TMap<class FName, struct FStructCookedMetaDataStore> FunctionsMetaData;                          // 0x00C8(0x0050)(Protected, NativeAccessSpecifierProtected)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ClassCookedMetaData">();
	}
	static class UClassCookedMetaData* GetDefaultObj()
	{
		return GetDefaultObjImpl<UClassCookedMetaData>();
	}
};
static_assert(alignof(UClassCookedMetaData) == 0x000008, "Wrong alignment on UClassCookedMetaData");
static_assert(sizeof(UClassCookedMetaData) == 0x000118, "Wrong size on UClassCookedMetaData");
static_assert(offsetof(UClassCookedMetaData, ClassMetaData) == 0x000028, "Member 'UClassCookedMetaData::ClassMetaData' has a wrong offset!");
static_assert(offsetof(UClassCookedMetaData, FunctionsMetaData) == 0x0000C8, "Member 'UClassCookedMetaData::FunctionsMetaData' has a wrong offset!");

// Class Engine.GarbageCollectionSettings
// 0x0020 (0x0058 - 0x0038)
class UGarbageCollectionSettings final : public UDeveloperSettings
{
public:
	float                                         TimeBetweenPurgingPendingKillObjects;              // 0x0038(0x0004)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         FlushStreamingOnGC : 1;                            // 0x003C(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, Config, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
	uint8                                         AllowParallelGC : 1;                               // 0x003C(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, Config, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
	uint8                                         IncrementalBeginDestroyEnabled : 1;                // 0x003C(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Edit, Config, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
	uint8                                         MultithreadedDestructionEnabled : 1;               // 0x003C(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (Edit, Config, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
	uint8                                         CreateGCClusters : 1;                              // 0x003C(0x0001)(BitIndex: 0x04, PropSize: 0x0001 (Edit, Config, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
	uint8                                         AssetClusteringEnabled : 1;                        // 0x003C(0x0001)(BitIndex: 0x05, PropSize: 0x0001 (Edit, Config, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
	uint8                                         ActorClusteringEnabled : 1;                        // 0x003C(0x0001)(BitIndex: 0x06, PropSize: 0x0001 (Edit, Config, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
	uint8                                         UseDisregardForGCOnDedicatedServers : 1;           // 0x003C(0x0001)(BitIndex: 0x07, PropSize: 0x0001 (Edit, Config, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
	uint8                                         VerifyUObjectsAreNotFGCObjects : 1;                // 0x003D(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, Config, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
	uint8                                         PendingKillEnabled : 1;                            // 0x003D(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, Config, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
	uint8                                         DumpObjectCountsToLogWhenMaxObjectLimitExceeded : 1; // 0x003D(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Edit, Config, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
	uint8                                         Pad_3E[0x2];                                       // 0x003E(0x0002)(Fixing Size After Last Property [ Dumper-7 ])
	int32                                         MinGCClusterSize;                                  // 0x0040(0x0004)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	int32                                         NumRetriesBeforeForcingGC;                         // 0x0044(0x0004)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	int32                                         MaxObjectsNotConsideredByGC;                       // 0x0048(0x0004)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	int32                                         SizeOfPermanentObjectPool;                         // 0x004C(0x0004)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	int32                                         MaxObjectsInGame;                                  // 0x0050(0x0004)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	int32                                         MaxObjectsInEditor;                                // 0x0054(0x0004)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"GarbageCollectionSettings">();
	}
	static class UGarbageCollectionSettings* GetDefaultObj()
	{
		return GetDefaultObjImpl<UGarbageCollectionSettings>();
	}
};
static_assert(alignof(UGarbageCollectionSettings) == 0x000008, "Wrong alignment on UGarbageCollectionSettings");
static_assert(sizeof(UGarbageCollectionSettings) == 0x000058, "Wrong size on UGarbageCollectionSettings");
static_assert(offsetof(UGarbageCollectionSettings, TimeBetweenPurgingPendingKillObjects) == 0x000038, "Member 'UGarbageCollectionSettings::TimeBetweenPurgingPendingKillObjects' has a wrong offset!");
static_assert(offsetof(UGarbageCollectionSettings, MinGCClusterSize) == 0x000040, "Member 'UGarbageCollectionSettings::MinGCClusterSize' has a wrong offset!");
static_assert(offsetof(UGarbageCollectionSettings, NumRetriesBeforeForcingGC) == 0x000044, "Member 'UGarbageCollectionSettings::NumRetriesBeforeForcingGC' has a wrong offset!");
static_assert(offsetof(UGarbageCollectionSettings, MaxObjectsNotConsideredByGC) == 0x000048, "Member 'UGarbageCollectionSettings::MaxObjectsNotConsideredByGC' has a wrong offset!");
static_assert(offsetof(UGarbageCollectionSettings, SizeOfPermanentObjectPool) == 0x00004C, "Member 'UGarbageCollectionSettings::SizeOfPermanentObjectPool' has a wrong offset!");
static_assert(offsetof(UGarbageCollectionSettings, MaxObjectsInGame) == 0x000050, "Member 'UGarbageCollectionSettings::MaxObjectsInGame' has a wrong offset!");
static_assert(offsetof(UGarbageCollectionSettings, MaxObjectsInEditor) == 0x000054, "Member 'UGarbageCollectionSettings::MaxObjectsInEditor' has a wrong offset!");

// Class Engine.CullDistanceVolume
// 0x0018 (0x02F0 - 0x02D8)
class ACullDistanceVolume final : public AVolume
{
public:
	TArray<struct FCullDistanceSizePair>          CullDistances;                                     // 0x02D8(0x0010)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, NativeAccessSpecifierPublic)
	uint8                                         bEnabled : 1;                                      // 0x02E8(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_2E9[0x7];                                      // 0x02E9(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"CullDistanceVolume">();
	}
	static class ACullDistanceVolume* GetDefaultObj()
	{
		return GetDefaultObjImpl<ACullDistanceVolume>();
	}
};
static_assert(alignof(ACullDistanceVolume) == 0x000008, "Wrong alignment on ACullDistanceVolume");
static_assert(sizeof(ACullDistanceVolume) == 0x0002F0, "Wrong size on ACullDistanceVolume");
static_assert(offsetof(ACullDistanceVolume, CullDistances) == 0x0002D8, "Member 'ACullDistanceVolume::CullDistances' has a wrong offset!");

// Class Engine.CurveLinearColor
// 0x0220 (0x0250 - 0x0030)
class UCurveLinearColor final : public UCurveBase
{
public:
	struct FRichCurve                             FloatCurves[0x4];                                  // 0x0030(0x0080)(NativeAccessSpecifierPublic)
	float                                         AdjustHue;                                         // 0x0230(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         AdjustSaturation;                                  // 0x0234(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         AdjustBrightness;                                  // 0x0238(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         AdjustBrightnessCurve;                             // 0x023C(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         AdjustVibrance;                                    // 0x0240(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         AdjustMinAlpha;                                    // 0x0244(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         AdjustMaxAlpha;                                    // 0x0248(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_24C[0x4];                                      // 0x024C(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	struct FLinearColor GetClampedLinearColorValue(float InTime) const;
	struct FLinearColor GetLinearColorValue(float InTime) const;
	struct FLinearColor GetUnadjustedLinearColorValue(float InTime) const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"CurveLinearColor">();
	}
	static class UCurveLinearColor* GetDefaultObj()
	{
		return GetDefaultObjImpl<UCurveLinearColor>();
	}
};
static_assert(alignof(UCurveLinearColor) == 0x000008, "Wrong alignment on UCurveLinearColor");
static_assert(sizeof(UCurveLinearColor) == 0x000250, "Wrong size on UCurveLinearColor");
static_assert(offsetof(UCurveLinearColor, FloatCurves) == 0x000030, "Member 'UCurveLinearColor::FloatCurves' has a wrong offset!");
static_assert(offsetof(UCurveLinearColor, AdjustHue) == 0x000230, "Member 'UCurveLinearColor::AdjustHue' has a wrong offset!");
static_assert(offsetof(UCurveLinearColor, AdjustSaturation) == 0x000234, "Member 'UCurveLinearColor::AdjustSaturation' has a wrong offset!");
static_assert(offsetof(UCurveLinearColor, AdjustBrightness) == 0x000238, "Member 'UCurveLinearColor::AdjustBrightness' has a wrong offset!");
static_assert(offsetof(UCurveLinearColor, AdjustBrightnessCurve) == 0x00023C, "Member 'UCurveLinearColor::AdjustBrightnessCurve' has a wrong offset!");
static_assert(offsetof(UCurveLinearColor, AdjustVibrance) == 0x000240, "Member 'UCurveLinearColor::AdjustVibrance' has a wrong offset!");
static_assert(offsetof(UCurveLinearColor, AdjustMinAlpha) == 0x000244, "Member 'UCurveLinearColor::AdjustMinAlpha' has a wrong offset!");
static_assert(offsetof(UCurveLinearColor, AdjustMaxAlpha) == 0x000248, "Member 'UCurveLinearColor::AdjustMaxAlpha' has a wrong offset!");

// Class Engine.CurveLinearColorAtlas
// 0x0020 (0x02A0 - 0x0280)
class UCurveLinearColorAtlas final : public UTexture2D
{
public:
	uint32                                        TextureSize;                                       // 0x0278(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bSquareResolution : 1;                             // 0x027C(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_27D[0x3];                                      // 0x027D(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	uint32                                        TextureHeight;                                     // 0x0280(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_284[0x4];                                      // 0x0284(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<class UCurveLinearColor*>              GradientCurves;                                    // 0x0288(0x0010)(Edit, ZeroConstructor, UObjectWrapper, NativeAccessSpecifierPublic)
	uint8                                         Pad_298[0x8];                                      // 0x0298(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	bool GetCurvePosition(class UCurveLinearColor* InCurve, float* position);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"CurveLinearColorAtlas">();
	}
	static class UCurveLinearColorAtlas* GetDefaultObj()
	{
		return GetDefaultObjImpl<UCurveLinearColorAtlas>();
	}
};
static_assert(alignof(UCurveLinearColorAtlas) == 0x000010, "Wrong alignment on UCurveLinearColorAtlas");
static_assert(sizeof(UCurveLinearColorAtlas) == 0x0002A0, "Wrong size on UCurveLinearColorAtlas");
static_assert(offsetof(UCurveLinearColorAtlas, TextureSize) == 0x000278, "Member 'UCurveLinearColorAtlas::TextureSize' has a wrong offset!");
static_assert(offsetof(UCurveLinearColorAtlas, TextureHeight) == 0x000280, "Member 'UCurveLinearColorAtlas::TextureHeight' has a wrong offset!");
static_assert(offsetof(UCurveLinearColorAtlas, GradientCurves) == 0x000288, "Member 'UCurveLinearColorAtlas::GradientCurves' has a wrong offset!");

// Class Engine.DataDrivenCVarEngineSubsystem
// 0x0010 (0x0040 - 0x0030)
class UDataDrivenCVarEngineSubsystem final : public UEngineSubsystem
{
public:
	TMulticastInlineDelegate<void(const class FString& CVarName)> OnDataDrivenCVarDelegate;          // 0x0030(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"DataDrivenCVarEngineSubsystem">();
	}
	static class UDataDrivenCVarEngineSubsystem* GetDefaultObj()
	{
		return GetDefaultObjImpl<UDataDrivenCVarEngineSubsystem>();
	}
};
static_assert(alignof(UDataDrivenCVarEngineSubsystem) == 0x000008, "Wrong alignment on UDataDrivenCVarEngineSubsystem");
static_assert(sizeof(UDataDrivenCVarEngineSubsystem) == 0x000040, "Wrong size on UDataDrivenCVarEngineSubsystem");
static_assert(offsetof(UDataDrivenCVarEngineSubsystem, OnDataDrivenCVarDelegate) == 0x000030, "Member 'UDataDrivenCVarEngineSubsystem::OnDataDrivenCVarDelegate' has a wrong offset!");

// Class Engine.DebugCameraController
// 0x0180 (0x09E0 - 0x0860)
class ADebugCameraController final : public APlayerController
{
public:
	uint8                                         bShowSelectedInfo : 1;                             // 0x0860(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Config, GlobalConfig, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bIsFrozenRendering : 1;                            // 0x0860(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bIsOrbitingSelectedActor : 1;                      // 0x0860(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bOrbitPivotUseCenter : 1;                          // 0x0860(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bEnableBufferVisualization : 1;                    // 0x0860(0x0001)(BitIndex: 0x04, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bEnableBufferVisualizationFullMode : 1;            // 0x0860(0x0001)(BitIndex: 0x05, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bIsBufferVisualizationInputSetup : 1;              // 0x0860(0x0001)(BitIndex: 0x06, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bLastDisplayEnabled : 1;                           // 0x0860(0x0001)(BitIndex: 0x07, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_861[0x7];                                      // 0x0861(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	class UDrawFrustumComponent*                  DrawFrustum;                                       // 0x0868(0x0008)(ExportObject, ZeroConstructor, InstancedReference, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TWeakObjectPtr<class AActor>                  SelectedActor;                                     // 0x0870(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TWeakObjectPtr<class UPrimitiveComponent>     SelectedComponent;                                 // 0x0878(0x0008)(ExportObject, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FHitResult                             SelectedHitPoint;                                  // 0x0880(0x00E8)(IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
	class APlayerController*                      OriginalControllerRef;                             // 0x0968(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UPlayer*                                OriginalPlayer;                                    // 0x0970(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         SpeedScale;                                        // 0x0978(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         InitialMaxSpeed;                                   // 0x097C(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         InitialAccel;                                      // 0x0980(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         InitialDecel;                                      // 0x0984(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_988[0x58];                                     // 0x0988(0x0058)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void ReceiveOnActivate(class APlayerController* OriginalPC);
	void ReceiveOnActorSelected(class AActor* NewSelectedActor, const struct FVector& SelectHitLocation, const struct FVector& SelectHitNormal, const struct FHitResult& Hit);
	void ReceiveOnDeactivate(class APlayerController* RestoredPC);
	void SetPawnMovementSpeedScale(float NewSpeedScale);
	void ShowDebugSelectedInfo();
	void ToggleDisplay();

	class AActor* GetSelectedActor() const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"DebugCameraController">();
	}
	static class ADebugCameraController* GetDefaultObj()
	{
		return GetDefaultObjImpl<ADebugCameraController>();
	}
};
static_assert(alignof(ADebugCameraController) == 0x000008, "Wrong alignment on ADebugCameraController");
static_assert(sizeof(ADebugCameraController) == 0x0009E0, "Wrong size on ADebugCameraController");
static_assert(offsetof(ADebugCameraController, DrawFrustum) == 0x000868, "Member 'ADebugCameraController::DrawFrustum' has a wrong offset!");
static_assert(offsetof(ADebugCameraController, SelectedActor) == 0x000870, "Member 'ADebugCameraController::SelectedActor' has a wrong offset!");
static_assert(offsetof(ADebugCameraController, SelectedComponent) == 0x000878, "Member 'ADebugCameraController::SelectedComponent' has a wrong offset!");
static_assert(offsetof(ADebugCameraController, SelectedHitPoint) == 0x000880, "Member 'ADebugCameraController::SelectedHitPoint' has a wrong offset!");
static_assert(offsetof(ADebugCameraController, OriginalControllerRef) == 0x000968, "Member 'ADebugCameraController::OriginalControllerRef' has a wrong offset!");
static_assert(offsetof(ADebugCameraController, OriginalPlayer) == 0x000970, "Member 'ADebugCameraController::OriginalPlayer' has a wrong offset!");
static_assert(offsetof(ADebugCameraController, SpeedScale) == 0x000978, "Member 'ADebugCameraController::SpeedScale' has a wrong offset!");
static_assert(offsetof(ADebugCameraController, InitialMaxSpeed) == 0x00097C, "Member 'ADebugCameraController::InitialMaxSpeed' has a wrong offset!");
static_assert(offsetof(ADebugCameraController, InitialAccel) == 0x000980, "Member 'ADebugCameraController::InitialAccel' has a wrong offset!");
static_assert(offsetof(ADebugCameraController, InitialDecel) == 0x000984, "Member 'ADebugCameraController::InitialDecel' has a wrong offset!");

// Class Engine.DebugCameraControllerSettings
// 0x0010 (0x0048 - 0x0038)
class UDebugCameraControllerSettings final : public UDeveloperSettings
{
public:
	TArray<struct FDebugCameraControllerSettingsViewModeIndex> CycleViewModes;                       // 0x0038(0x0010)(Edit, ZeroConstructor, Config, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"DebugCameraControllerSettings">();
	}
	static class UDebugCameraControllerSettings* GetDefaultObj()
	{
		return GetDefaultObjImpl<UDebugCameraControllerSettings>();
	}
};
static_assert(alignof(UDebugCameraControllerSettings) == 0x000008, "Wrong alignment on UDebugCameraControllerSettings");
static_assert(sizeof(UDebugCameraControllerSettings) == 0x000048, "Wrong size on UDebugCameraControllerSettings");
static_assert(offsetof(UDebugCameraControllerSettings, CycleViewModes) == 0x000038, "Member 'UDebugCameraControllerSettings::CycleViewModes' has a wrong offset!");

// Class Engine.ReporterGraph
// 0x0098 (0x00C8 - 0x0030)
class UReporterGraph final : public UReporterBase
{
public:
	uint8                                         Pad_30[0x98];                                      // 0x0030(0x0098)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ReporterGraph">();
	}
	static class UReporterGraph* GetDefaultObj()
	{
		return GetDefaultObjImpl<UReporterGraph>();
	}
};
static_assert(alignof(UReporterGraph) == 0x000008, "Wrong alignment on UReporterGraph");
static_assert(sizeof(UReporterGraph) == 0x0000C8, "Wrong size on UReporterGraph");

// Class Engine.DefaultPawn
// 0x0028 (0x0350 - 0x0328)
class ADefaultPawn : public APawn
{
public:
	float                                         BaseTurnRate;                                      // 0x0328(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, EditConst, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         BaseLookUpRate;                                    // 0x032C(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, EditConst, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UPawnMovementComponent*                 MovementComponent;                                 // 0x0330(0x0008)(Edit, BlueprintVisible, ExportObject, BlueprintReadOnly, ZeroConstructor, EditConst, InstancedReference, NoDestructor, Protected, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	class USphereComponent*                       CollisionComponent;                                // 0x0338(0x0008)(Edit, BlueprintVisible, ExportObject, BlueprintReadOnly, ZeroConstructor, EditConst, InstancedReference, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	class UStaticMeshComponent*                   MeshComponent;                                     // 0x0340(0x0008)(Edit, BlueprintVisible, ExportObject, BlueprintReadOnly, ZeroConstructor, EditConst, InstancedReference, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         bAddDefaultMovementBindings : 1;                   // 0x0348(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_349[0x7];                                      // 0x0349(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void LookUpAtRate(float Rate);
	void MoveForward(float val);
	void MoveRight(float val);
	void MoveUp_World(float val);
	void TurnAtRate(float Rate);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"DefaultPawn">();
	}
	static class ADefaultPawn* GetDefaultObj()
	{
		return GetDefaultObjImpl<ADefaultPawn>();
	}
};
static_assert(alignof(ADefaultPawn) == 0x000008, "Wrong alignment on ADefaultPawn");
static_assert(sizeof(ADefaultPawn) == 0x000350, "Wrong size on ADefaultPawn");
static_assert(offsetof(ADefaultPawn, BaseTurnRate) == 0x000328, "Member 'ADefaultPawn::BaseTurnRate' has a wrong offset!");
static_assert(offsetof(ADefaultPawn, BaseLookUpRate) == 0x00032C, "Member 'ADefaultPawn::BaseLookUpRate' has a wrong offset!");
static_assert(offsetof(ADefaultPawn, MovementComponent) == 0x000330, "Member 'ADefaultPawn::MovementComponent' has a wrong offset!");
static_assert(offsetof(ADefaultPawn, CollisionComponent) == 0x000338, "Member 'ADefaultPawn::CollisionComponent' has a wrong offset!");
static_assert(offsetof(ADefaultPawn, MeshComponent) == 0x000340, "Member 'ADefaultPawn::MeshComponent' has a wrong offset!");

// Class Engine.PhysicsVolume
// 0x0010 (0x02E8 - 0x02D8)
class APhysicsVolume : public AVolume
{
public:
	float                                         TerminalVelocity;                                  // 0x02D8(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         Priority;                                          // 0x02DC(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         FluidFriction;                                     // 0x02E0(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bWaterVolume : 1;                                  // 0x02E4(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bPhysicsOnContact : 1;                             // 0x02E4(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_2E5[0x3];                                      // 0x02E5(0x0003)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"PhysicsVolume">();
	}
	static class APhysicsVolume* GetDefaultObj()
	{
		return GetDefaultObjImpl<APhysicsVolume>();
	}
};
static_assert(alignof(APhysicsVolume) == 0x000008, "Wrong alignment on APhysicsVolume");
static_assert(sizeof(APhysicsVolume) == 0x0002E8, "Wrong size on APhysicsVolume");
static_assert(offsetof(APhysicsVolume, TerminalVelocity) == 0x0002D8, "Member 'APhysicsVolume::TerminalVelocity' has a wrong offset!");
static_assert(offsetof(APhysicsVolume, Priority) == 0x0002DC, "Member 'APhysicsVolume::Priority' has a wrong offset!");
static_assert(offsetof(APhysicsVolume, FluidFriction) == 0x0002E0, "Member 'APhysicsVolume::FluidFriction' has a wrong offset!");

// Class Engine.DefaultPhysicsVolume
// 0x0000 (0x02E8 - 0x02E8)
class ADefaultPhysicsVolume final : public APhysicsVolume
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"DefaultPhysicsVolume">();
	}
	static class ADefaultPhysicsVolume* GetDefaultObj()
	{
		return GetDefaultObjImpl<ADefaultPhysicsVolume>();
	}
};
static_assert(alignof(ADefaultPhysicsVolume) == 0x000008, "Wrong alignment on ADefaultPhysicsVolume");
static_assert(sizeof(ADefaultPhysicsVolume) == 0x0002E8, "Wrong size on ADefaultPhysicsVolume");

// Class Engine.NetDriver
// 0x07C8 (0x07F0 - 0x0028)
class UNetDriver : public UObject
{
public:
	uint8                                         Pad_28[0x8];                                       // 0x0028(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	class FString                                 NetConnectionClassName;                            // 0x0030(0x0010)(ZeroConstructor, Config, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FString                                 ReplicationDriverClassName;                        // 0x0040(0x0010)(ZeroConstructor, Config, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FString                                 ReplicationBridgeClassName;                        // 0x0050(0x0010)(ZeroConstructor, Config, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FNetDriverReplicationSystemConfig      ReplicationSystemConfig;                           // 0x0060(0x000C)(Config, NoDestructor, NativeAccessSpecifierPublic)
	int32                                         MaxDownloadSize;                                   // 0x006C(0x0004)(ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bClampListenServerTickRate : 1;                    // 0x0070(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_71[0x3];                                       // 0x0071(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	int32                                         NetServerMaxTickRate;                              // 0x0074(0x0004)(ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_78[0x18];                                      // 0x0078(0x0018)(Fixing Size After Last Property [ Dumper-7 ])
	int32                                         MaxNetTickRate;                                    // 0x0090(0x0004)(ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         MaxInternetClientRate;                             // 0x0094(0x0004)(ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         MaxClientRate;                                     // 0x0098(0x0004)(ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         ServerTravelPause;                                 // 0x009C(0x0004)(ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         SpawnPrioritySeconds;                              // 0x00A0(0x0004)(ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         RelevantTimeout;                                   // 0x00A4(0x0004)(ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         KeepAliveTime;                                     // 0x00A8(0x0004)(ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         InitialConnectTimeout;                             // 0x00AC(0x0004)(ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         ConnectionTimeout;                                 // 0x00B0(0x0004)(ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         TimeoutMultiplierForUnoptimizedBuilds;             // 0x00B4(0x0004)(ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UNetConnection*                         ServerConnection;                                  // 0x00B8(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TArray<class UNetConnection*>                 ClientConnections;                                 // 0x00C0(0x0010)(ZeroConstructor, UObjectWrapper, NativeAccessSpecifierPublic)
	uint8                                         Pad_D0[0x60];                                      // 0x00D0(0x0060)(Fixing Size After Last Property [ Dumper-7 ])
	int32                                         RecentlyDisconnectedTrackingTime;                  // 0x0130(0x0004)(ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_134[0x3C];                                     // 0x0134(0x003C)(Fixing Size After Last Property [ Dumper-7 ])
	class UWorld*                                 World;                                             // 0x0170(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UPackage*                               WorldPackage;                                      // 0x0178(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_180[0x20];                                     // 0x0180(0x0020)(Fixing Size After Last Property [ Dumper-7 ])
	TSubclassOf<class UObject>                    NetConnectionClass;                                // 0x01A0(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TSubclassOf<class UObject>                    ReplicationDriverClass;                            // 0x01A8(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TSubclassOf<class UObject>                    ReplicationBridgeClass;                            // 0x01B0(0x0008)(ZeroConstructor, Transient, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1B8[0x10];                                     // 0x01B8(0x0010)(Fixing Size After Last Property [ Dumper-7 ])
	class FName                                   NetDriverName;                                     // 0x01C8(0x0008)(ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TArray<struct FChannelDefinition>             ChannelDefinitions;                                // 0x01D0(0x0010)(ZeroConstructor, Config, NativeAccessSpecifierPublic)
	TMap<class FName, struct FChannelDefinition>  ChannelDefinitionMap;                              // 0x01E0(0x0050)(NativeAccessSpecifierPublic)
	TArray<class UChannel*>                       ActorChannelPool;                                  // 0x0230(0x0010)(ZeroConstructor, UObjectWrapper, NativeAccessSpecifierPrivate)
	uint8                                         Pad_240[0x21];                                     // 0x0240(0x0021)(Fixing Size After Last Property [ Dumper-7 ])
	uint8                                         BitPad_261_0 : 6;                                  // 0x0261(0x0001)(Fixing Bit-Field Size Between Bits [ Dumper-7 ])
	uint8                                         bNoTimeouts : 1;                                   // 0x0261(0x0001)(BitIndex: 0x06, PropSize: 0x0001 (Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bNeverApplyNetworkEmulationSettings : 1;           // 0x0261(0x0001)(BitIndex: 0x07, PropSize: 0x0001 (Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_262[0x506];                                    // 0x0262(0x0506)(Fixing Size After Last Property [ Dumper-7 ])
	class UReplicationDriver*                     ReplicationDriver;                                 // 0x0768(0x0008)(ZeroConstructor, Transient, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_770[0x80];                                     // 0x0770(0x0080)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"NetDriver">();
	}
	static class UNetDriver* GetDefaultObj()
	{
		return GetDefaultObjImpl<UNetDriver>();
	}
};
static_assert(alignof(UNetDriver) == 0x000008, "Wrong alignment on UNetDriver");
static_assert(sizeof(UNetDriver) == 0x0007F0, "Wrong size on UNetDriver");
static_assert(offsetof(UNetDriver, NetConnectionClassName) == 0x000030, "Member 'UNetDriver::NetConnectionClassName' has a wrong offset!");
static_assert(offsetof(UNetDriver, ReplicationDriverClassName) == 0x000040, "Member 'UNetDriver::ReplicationDriverClassName' has a wrong offset!");
static_assert(offsetof(UNetDriver, ReplicationBridgeClassName) == 0x000050, "Member 'UNetDriver::ReplicationBridgeClassName' has a wrong offset!");
static_assert(offsetof(UNetDriver, ReplicationSystemConfig) == 0x000060, "Member 'UNetDriver::ReplicationSystemConfig' has a wrong offset!");
static_assert(offsetof(UNetDriver, MaxDownloadSize) == 0x00006C, "Member 'UNetDriver::MaxDownloadSize' has a wrong offset!");
static_assert(offsetof(UNetDriver, NetServerMaxTickRate) == 0x000074, "Member 'UNetDriver::NetServerMaxTickRate' has a wrong offset!");
static_assert(offsetof(UNetDriver, MaxNetTickRate) == 0x000090, "Member 'UNetDriver::MaxNetTickRate' has a wrong offset!");
static_assert(offsetof(UNetDriver, MaxInternetClientRate) == 0x000094, "Member 'UNetDriver::MaxInternetClientRate' has a wrong offset!");
static_assert(offsetof(UNetDriver, MaxClientRate) == 0x000098, "Member 'UNetDriver::MaxClientRate' has a wrong offset!");
static_assert(offsetof(UNetDriver, ServerTravelPause) == 0x00009C, "Member 'UNetDriver::ServerTravelPause' has a wrong offset!");
static_assert(offsetof(UNetDriver, SpawnPrioritySeconds) == 0x0000A0, "Member 'UNetDriver::SpawnPrioritySeconds' has a wrong offset!");
static_assert(offsetof(UNetDriver, RelevantTimeout) == 0x0000A4, "Member 'UNetDriver::RelevantTimeout' has a wrong offset!");
static_assert(offsetof(UNetDriver, KeepAliveTime) == 0x0000A8, "Member 'UNetDriver::KeepAliveTime' has a wrong offset!");
static_assert(offsetof(UNetDriver, InitialConnectTimeout) == 0x0000AC, "Member 'UNetDriver::InitialConnectTimeout' has a wrong offset!");
static_assert(offsetof(UNetDriver, ConnectionTimeout) == 0x0000B0, "Member 'UNetDriver::ConnectionTimeout' has a wrong offset!");
static_assert(offsetof(UNetDriver, TimeoutMultiplierForUnoptimizedBuilds) == 0x0000B4, "Member 'UNetDriver::TimeoutMultiplierForUnoptimizedBuilds' has a wrong offset!");
static_assert(offsetof(UNetDriver, ServerConnection) == 0x0000B8, "Member 'UNetDriver::ServerConnection' has a wrong offset!");
static_assert(offsetof(UNetDriver, ClientConnections) == 0x0000C0, "Member 'UNetDriver::ClientConnections' has a wrong offset!");
static_assert(offsetof(UNetDriver, RecentlyDisconnectedTrackingTime) == 0x000130, "Member 'UNetDriver::RecentlyDisconnectedTrackingTime' has a wrong offset!");
static_assert(offsetof(UNetDriver, World) == 0x000170, "Member 'UNetDriver::World' has a wrong offset!");
static_assert(offsetof(UNetDriver, WorldPackage) == 0x000178, "Member 'UNetDriver::WorldPackage' has a wrong offset!");
static_assert(offsetof(UNetDriver, NetConnectionClass) == 0x0001A0, "Member 'UNetDriver::NetConnectionClass' has a wrong offset!");
static_assert(offsetof(UNetDriver, ReplicationDriverClass) == 0x0001A8, "Member 'UNetDriver::ReplicationDriverClass' has a wrong offset!");
static_assert(offsetof(UNetDriver, ReplicationBridgeClass) == 0x0001B0, "Member 'UNetDriver::ReplicationBridgeClass' has a wrong offset!");
static_assert(offsetof(UNetDriver, NetDriverName) == 0x0001C8, "Member 'UNetDriver::NetDriverName' has a wrong offset!");
static_assert(offsetof(UNetDriver, ChannelDefinitions) == 0x0001D0, "Member 'UNetDriver::ChannelDefinitions' has a wrong offset!");
static_assert(offsetof(UNetDriver, ChannelDefinitionMap) == 0x0001E0, "Member 'UNetDriver::ChannelDefinitionMap' has a wrong offset!");
static_assert(offsetof(UNetDriver, ActorChannelPool) == 0x000230, "Member 'UNetDriver::ActorChannelPool' has a wrong offset!");
static_assert(offsetof(UNetDriver, ReplicationDriver) == 0x000768, "Member 'UNetDriver::ReplicationDriver' has a wrong offset!");

// Class Engine.DemoNetDriver
// 0x0CC0 (0x14B0 - 0x07F0)
class alignas(0x10) UDemoNetDriver final : public UNetDriver
{
public:
	uint8                                         Pad_7F0[0x38];                                     // 0x07F0(0x0038)(Fixing Size After Last Property [ Dumper-7 ])
	TMap<class FString, struct FRollbackNetStartupActorInfo> RollbackNetStartupActors;               // 0x0828(0x0050)(Transient, NativeAccessSpecifierPrivate)
	uint8                                         Pad_878[0xE4];                                     // 0x0878(0x00E4)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         CheckpointSaveMaxMSPerFrame;                       // 0x095C(0x0004)(ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_960[0x18];                                     // 0x0960(0x0018)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<struct FMulticastRecordOptions>        MulticastRecordOptions;                            // 0x0978(0x0010)(ZeroConstructor, Config, NativeAccessSpecifierPrivate)
	TArray<class APlayerController*>              SpectatorControllers;                              // 0x0988(0x0010)(ZeroConstructor, Transient, UObjectWrapper, NativeAccessSpecifierPrivate)
	uint8                                         Pad_998[0xB18];                                    // 0x0998(0x0B18)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"DemoNetDriver">();
	}
	static class UDemoNetDriver* GetDefaultObj()
	{
		return GetDefaultObjImpl<UDemoNetDriver>();
	}
};
static_assert(alignof(UDemoNetDriver) == 0x000010, "Wrong alignment on UDemoNetDriver");
static_assert(sizeof(UDemoNetDriver) == 0x0014B0, "Wrong size on UDemoNetDriver");
static_assert(offsetof(UDemoNetDriver, RollbackNetStartupActors) == 0x000828, "Member 'UDemoNetDriver::RollbackNetStartupActors' has a wrong offset!");
static_assert(offsetof(UDemoNetDriver, CheckpointSaveMaxMSPerFrame) == 0x00095C, "Member 'UDemoNetDriver::CheckpointSaveMaxMSPerFrame' has a wrong offset!");
static_assert(offsetof(UDemoNetDriver, MulticastRecordOptions) == 0x000978, "Member 'UDemoNetDriver::MulticastRecordOptions' has a wrong offset!");
static_assert(offsetof(UDemoNetDriver, SpectatorControllers) == 0x000988, "Member 'UDemoNetDriver::SpectatorControllers' has a wrong offset!");

// Class Engine.DestructibleInterface
// 0x0000 (0x0000 - 0x0000)
class IDestructibleInterface final
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"DestructibleInterface">();
	}
	static class IDestructibleInterface* GetDefaultObj()
	{
		return GetDefaultObjImpl<IDestructibleInterface>();
	}

	class UObject* AsUObject()
	{
		return reinterpret_cast<UObject*>(this);
	}
	const class UObject* AsUObject() const
	{
		return reinterpret_cast<const UObject*>(this);
	}
};
static_assert(alignof(IDestructibleInterface) == 0x000001, "Wrong alignment on IDestructibleInterface");
static_assert(sizeof(IDestructibleInterface) == 0x000001, "Wrong size on IDestructibleInterface");

// Class Engine.DeviceProfile
// 0x0098 (0x00D0 - 0x0038)
class UDeviceProfile final : public UTextureLODSettings
{
public:
	class FString                                 DeviceType;                                        // 0x0038(0x0010)(Edit, ZeroConstructor, Config, EditConst, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FString                                 BaseProfileName;                                   // 0x0048(0x0010)(Edit, ZeroConstructor, Config, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bIsVisibleForAssets : 1;                           // 0x0058(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_59[0x7];                                       // 0x0059(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	class UDeviceProfile*                         Parent;                                            // 0x0060(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_68[0x28];                                      // 0x0068(0x0028)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<class FString>                         CVars;                                             // 0x0090(0x0010)(Edit, ZeroConstructor, Config, NativeAccessSpecifierPublic)
	TArray<struct FDPMatchingRulestruct>          MatchingRules;                                     // 0x00A0(0x0010)(Edit, ZeroConstructor, Config, NativeAccessSpecifierPublic)
	uint8                                         Pad_B0[0x20];                                      // 0x00B0(0x0020)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"DeviceProfile">();
	}
	static class UDeviceProfile* GetDefaultObj()
	{
		return GetDefaultObjImpl<UDeviceProfile>();
	}
};
static_assert(alignof(UDeviceProfile) == 0x000008, "Wrong alignment on UDeviceProfile");
static_assert(sizeof(UDeviceProfile) == 0x0000D0, "Wrong size on UDeviceProfile");
static_assert(offsetof(UDeviceProfile, DeviceType) == 0x000038, "Member 'UDeviceProfile::DeviceType' has a wrong offset!");
static_assert(offsetof(UDeviceProfile, BaseProfileName) == 0x000048, "Member 'UDeviceProfile::BaseProfileName' has a wrong offset!");
static_assert(offsetof(UDeviceProfile, Parent) == 0x000060, "Member 'UDeviceProfile::Parent' has a wrong offset!");
static_assert(offsetof(UDeviceProfile, CVars) == 0x000090, "Member 'UDeviceProfile::CVars' has a wrong offset!");
static_assert(offsetof(UDeviceProfile, MatchingRules) == 0x0000A0, "Member 'UDeviceProfile::MatchingRules' has a wrong offset!");

// Class Engine.DeviceProfileManager
// 0x0068 (0x0090 - 0x0028)
class UDeviceProfileManager final : public UObject
{
public:
	TArray<class UDeviceProfile*>                 Profiles;                                          // 0x0028(0x0010)(Edit, ZeroConstructor, UObjectWrapper, NativeAccessSpecifierPublic)
	TArray<class UDeviceProfile*>                 BackupProfiles;                                    // 0x0038(0x0010)(ZeroConstructor, UObjectWrapper, NativeAccessSpecifierPrivate)
	uint8                                         Pad_48[0x48];                                      // 0x0048(0x0048)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"DeviceProfileManager">();
	}
	static class UDeviceProfileManager* GetDefaultObj()
	{
		return GetDefaultObjImpl<UDeviceProfileManager>();
	}
};
static_assert(alignof(UDeviceProfileManager) == 0x000008, "Wrong alignment on UDeviceProfileManager");
static_assert(sizeof(UDeviceProfileManager) == 0x000090, "Wrong size on UDeviceProfileManager");
static_assert(offsetof(UDeviceProfileManager, Profiles) == 0x000028, "Member 'UDeviceProfileManager::Profiles' has a wrong offset!");
static_assert(offsetof(UDeviceProfileManager, BackupProfiles) == 0x000038, "Member 'UDeviceProfileManager::BackupProfiles' has a wrong offset!");

// Class Engine.DialogueVoice
// 0x0018 (0x0040 - 0x0028)
class UDialogueVoice final : public UObject
{
public:
	EGrammaticalGender                            Gender;                                            // 0x0028(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, AssetRegistrySearchable, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EGrammaticalNumber                            Plurality;                                         // 0x0029(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, AssetRegistrySearchable, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_2A[0x2];                                       // 0x002A(0x0002)(Fixing Size After Last Property [ Dumper-7 ])
	struct FGuid                                  LocalizationGUID;                                  // 0x002C(0x0010)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_3C[0x4];                                       // 0x003C(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"DialogueVoice">();
	}
	static class UDialogueVoice* GetDefaultObj()
	{
		return GetDefaultObjImpl<UDialogueVoice>();
	}
};
static_assert(alignof(UDialogueVoice) == 0x000008, "Wrong alignment on UDialogueVoice");
static_assert(sizeof(UDialogueVoice) == 0x000040, "Wrong size on UDialogueVoice");
static_assert(offsetof(UDialogueVoice, Gender) == 0x000028, "Member 'UDialogueVoice::Gender' has a wrong offset!");
static_assert(offsetof(UDialogueVoice, Plurality) == 0x000029, "Member 'UDialogueVoice::Plurality' has a wrong offset!");
static_assert(offsetof(UDialogueVoice, LocalizationGUID) == 0x00002C, "Member 'UDialogueVoice::LocalizationGUID' has a wrong offset!");

// Class Engine.DocumentationActor
// 0x0008 (0x02A8 - 0x02A0)
class ADocumentationActor final : public AActor
{
public:
	uint8                                         Pad_2A0[0x8];                                      // 0x02A0(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"DocumentationActor">();
	}
	static class ADocumentationActor* GetDefaultObj()
	{
		return GetDefaultObjImpl<ADocumentationActor>();
	}
};
static_assert(alignof(ADocumentationActor) == 0x000008, "Wrong alignment on ADocumentationActor");
static_assert(sizeof(ADocumentationActor) == 0x0002A8, "Wrong size on ADocumentationActor");

// Class Engine.DPICustomScalingRule
// 0x0000 (0x0028 - 0x0028)
class UDPICustomScalingRule final : public UObject
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"DPICustomScalingRule">();
	}
	static class UDPICustomScalingRule* GetDefaultObj()
	{
		return GetDefaultObjImpl<UDPICustomScalingRule>();
	}
};
static_assert(alignof(UDPICustomScalingRule) == 0x000008, "Wrong alignment on UDPICustomScalingRule");
static_assert(sizeof(UDPICustomScalingRule) == 0x000028, "Wrong size on UDPICustomScalingRule");

// Class Engine.EdGraphNode_Documentation
// 0x0020 (0x00B8 - 0x0098)
class UEdGraphNode_Documentation final : public UEdGraphNode
{
public:
	class FString                                 Link;                                              // 0x0098(0x0010)(ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FString                                 Excerpt;                                           // 0x00A8(0x0010)(ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"EdGraphNode_Documentation">();
	}
	static class UEdGraphNode_Documentation* GetDefaultObj()
	{
		return GetDefaultObjImpl<UEdGraphNode_Documentation>();
	}
};
static_assert(alignof(UEdGraphNode_Documentation) == 0x000008, "Wrong alignment on UEdGraphNode_Documentation");
static_assert(sizeof(UEdGraphNode_Documentation) == 0x0000B8, "Wrong size on UEdGraphNode_Documentation");
static_assert(offsetof(UEdGraphNode_Documentation, Link) == 0x000098, "Member 'UEdGraphNode_Documentation::Link' has a wrong offset!");
static_assert(offsetof(UEdGraphNode_Documentation, Excerpt) == 0x0000A8, "Member 'UEdGraphNode_Documentation::Excerpt' has a wrong offset!");

// Class Engine.ThumbnailInfo
// 0x0000 (0x0028 - 0x0028)
class UThumbnailInfo final : public UObject
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ThumbnailInfo">();
	}
	static class UThumbnailInfo* GetDefaultObj()
	{
		return GetDefaultObjImpl<UThumbnailInfo>();
	}
};
static_assert(alignof(UThumbnailInfo) == 0x000008, "Wrong alignment on UThumbnailInfo");
static_assert(sizeof(UThumbnailInfo) == 0x000028, "Wrong size on UThumbnailInfo");

// Class Engine.ActorElementAssetDataInterface
// 0x0008 (0x0030 - 0x0028)
class UActorElementAssetDataInterface final : public UObject
{
public:
	uint8                                         Pad_28[0x8];                                       // 0x0028(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ActorElementAssetDataInterface">();
	}
	static class UActorElementAssetDataInterface* GetDefaultObj()
	{
		return GetDefaultObjImpl<UActorElementAssetDataInterface>();
	}
};
static_assert(alignof(UActorElementAssetDataInterface) == 0x000008, "Wrong alignment on UActorElementAssetDataInterface");
static_assert(sizeof(UActorElementAssetDataInterface) == 0x000030, "Wrong size on UActorElementAssetDataInterface");

// Class Engine.ActorElementCounterInterface
// 0x0008 (0x0030 - 0x0028)
class UActorElementCounterInterface final : public UObject
{
public:
	uint8                                         Pad_28[0x8];                                       // 0x0028(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ActorElementCounterInterface">();
	}
	static class UActorElementCounterInterface* GetDefaultObj()
	{
		return GetDefaultObjImpl<UActorElementCounterInterface>();
	}
};
static_assert(alignof(UActorElementCounterInterface) == 0x000008, "Wrong alignment on UActorElementCounterInterface");
static_assert(sizeof(UActorElementCounterInterface) == 0x000030, "Wrong size on UActorElementCounterInterface");

// Class Engine.ActorElementObjectInterface
// 0x0008 (0x0030 - 0x0028)
class UActorElementObjectInterface final : public UObject
{
public:
	uint8                                         Pad_28[0x8];                                       // 0x0028(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ActorElementObjectInterface">();
	}
	static class UActorElementObjectInterface* GetDefaultObj()
	{
		return GetDefaultObjImpl<UActorElementObjectInterface>();
	}
};
static_assert(alignof(UActorElementObjectInterface) == 0x000008, "Wrong alignment on UActorElementObjectInterface");
static_assert(sizeof(UActorElementObjectInterface) == 0x000030, "Wrong size on UActorElementObjectInterface");

// Class Engine.ActorElementSelectionInterface
// 0x0008 (0x0030 - 0x0028)
class UActorElementSelectionInterface final : public UObject
{
public:
	uint8                                         Pad_28[0x8];                                       // 0x0028(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ActorElementSelectionInterface">();
	}
	static class UActorElementSelectionInterface* GetDefaultObj()
	{
		return GetDefaultObjImpl<UActorElementSelectionInterface>();
	}
};
static_assert(alignof(UActorElementSelectionInterface) == 0x000008, "Wrong alignment on UActorElementSelectionInterface");
static_assert(sizeof(UActorElementSelectionInterface) == 0x000030, "Wrong size on UActorElementSelectionInterface");

// Class Engine.ActorElementWorldInterface
// 0x0008 (0x0030 - 0x0028)
class UActorElementWorldInterface final : public UObject
{
public:
	uint8                                         Pad_28[0x8];                                       // 0x0028(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ActorElementWorldInterface">();
	}
	static class UActorElementWorldInterface* GetDefaultObj()
	{
		return GetDefaultObjImpl<UActorElementWorldInterface>();
	}
};
static_assert(alignof(UActorElementWorldInterface) == 0x000008, "Wrong alignment on UActorElementWorldInterface");
static_assert(sizeof(UActorElementWorldInterface) == 0x000030, "Wrong size on UActorElementWorldInterface");

// Class Engine.ComponentElementHierarchyInterface
// 0x0008 (0x0030 - 0x0028)
class UComponentElementHierarchyInterface final : public UObject
{
public:
	uint8                                         Pad_28[0x8];                                       // 0x0028(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ComponentElementHierarchyInterface">();
	}
	static class UComponentElementHierarchyInterface* GetDefaultObj()
	{
		return GetDefaultObjImpl<UComponentElementHierarchyInterface>();
	}
};
static_assert(alignof(UComponentElementHierarchyInterface) == 0x000008, "Wrong alignment on UComponentElementHierarchyInterface");
static_assert(sizeof(UComponentElementHierarchyInterface) == 0x000030, "Wrong size on UComponentElementHierarchyInterface");

// Class Engine.ComponentElementObjectInterface
// 0x0008 (0x0030 - 0x0028)
class UComponentElementObjectInterface final : public UObject
{
public:
	uint8                                         Pad_28[0x8];                                       // 0x0028(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ComponentElementObjectInterface">();
	}
	static class UComponentElementObjectInterface* GetDefaultObj()
	{
		return GetDefaultObjImpl<UComponentElementObjectInterface>();
	}
};
static_assert(alignof(UComponentElementObjectInterface) == 0x000008, "Wrong alignment on UComponentElementObjectInterface");
static_assert(sizeof(UComponentElementObjectInterface) == 0x000030, "Wrong size on UComponentElementObjectInterface");

// Class Engine.ComponentElementSelectionInterface
// 0x0008 (0x0030 - 0x0028)
class UComponentElementSelectionInterface final : public UObject
{
public:
	uint8                                         Pad_28[0x8];                                       // 0x0028(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ComponentElementSelectionInterface">();
	}
	static class UComponentElementSelectionInterface* GetDefaultObj()
	{
		return GetDefaultObjImpl<UComponentElementSelectionInterface>();
	}
};
static_assert(alignof(UComponentElementSelectionInterface) == 0x000008, "Wrong alignment on UComponentElementSelectionInterface");
static_assert(sizeof(UComponentElementSelectionInterface) == 0x000030, "Wrong size on UComponentElementSelectionInterface");

// Class Engine.EngineElementsLibrary
// 0x0000 (0x0028 - 0x0028)
class UEngineElementsLibrary final : public UBlueprintFunctionLibrary
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"EngineElementsLibrary">();
	}
	static class UEngineElementsLibrary* GetDefaultObj()
	{
		return GetDefaultObjImpl<UEngineElementsLibrary>();
	}
};
static_assert(alignof(UEngineElementsLibrary) == 0x000008, "Wrong alignment on UEngineElementsLibrary");
static_assert(sizeof(UEngineElementsLibrary) == 0x000028, "Wrong size on UEngineElementsLibrary");

// Class Engine.TypedElementCommonActions
// 0x0800 (0x0828 - 0x0028)
class UTypedElementCommonActions final : public UObject
{
public:
	uint8                                         Pad_28[0x800];                                     // 0x0028(0x0800)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	bool CopyNormalizedElements(const struct FScriptTypedElementListProxy& ElementList);
	bool CopyNormalizedElementsToString(const struct FScriptTypedElementListProxy& ElementList, class FString* OutputString);
	bool CopySelectedElements(class UTypedElementSelectionSet* SelectionSet);
	bool CopySelectedElementsToString(class UTypedElementSelectionSet* SelectionSet, class FString* OutputString);
	bool DeleteNormalizedElements(const struct FScriptTypedElementListProxy& ElementList, class UWorld* World, class UTypedElementSelectionSet* InSelectionSet, const struct FTypedElementDeletionOptions& DeletionOptions);
	bool DeleteSelectedElements(class UTypedElementSelectionSet* SelectionSet, class UWorld* World, const struct FTypedElementDeletionOptions& DeletionOptions);
	TArray<struct FScriptTypedElementHandle> DuplicateNormalizedElements(const struct FScriptTypedElementListProxy& ElementList, class UWorld* World, const struct FVector& LocationOffset);
	TArray<struct FScriptTypedElementHandle> K2_DuplicateSelectedElements(const class UTypedElementSelectionSet* SelectionSet, class UWorld* World, const struct FVector& LocationOffset);
	TArray<struct FScriptTypedElementHandle> K2_PasteElements(class UTypedElementSelectionSet* SelectionSet, class UWorld* World, const struct FTypedElementPasteOptions& PasteOption);
	TArray<struct FScriptTypedElementHandle> K2_PasteNormalizedElements(const struct FScriptTypedElementListProxy& ElementList, class UWorld* World, const struct FTypedElementPasteOptions& PasteOption);
	TArray<struct FScriptTypedElementHandle> PasteElementsFromString(class UTypedElementSelectionSet* SelectionSet, class UWorld* World, const struct FTypedElementPasteOptions& PasteOption, const class FString& InputString);
	TArray<struct FScriptTypedElementHandle> PasteNormalizedElementsFromString(const struct FScriptTypedElementListProxy& ElementList, class UWorld* World, const struct FTypedElementPasteOptions& PasteOption, const class FString& InputString);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"TypedElementCommonActions">();
	}
	static class UTypedElementCommonActions* GetDefaultObj()
	{
		return GetDefaultObjImpl<UTypedElementCommonActions>();
	}
};
static_assert(alignof(UTypedElementCommonActions) == 0x000008, "Wrong alignment on UTypedElementCommonActions");
static_assert(sizeof(UTypedElementCommonActions) == 0x000828, "Wrong size on UTypedElementCommonActions");

// Class Engine.TypedElementWorldInterface
// 0x0000 (0x0000 - 0x0000)
class ITypedElementWorldInterface final
{
public:
	bool CanDeleteElement(const struct FScriptTypedElementHandle& InElementHandle);
	bool CanDuplicateElement(const struct FScriptTypedElementHandle& InElementHandle);
	bool CanEditElement(const struct FScriptTypedElementHandle& InElementHandle);
	bool CanMoveElement(const struct FScriptTypedElementHandle& InElementHandle, const ETypedElementWorldType InWorldType);
	bool CanPromoteElement(const struct FScriptTypedElementHandle& InElementHandle);
	bool DeleteElement(const struct FScriptTypedElementHandle& InElementHandle, class UWorld* InWorld, class UTypedElementSelectionSet* InSelectionSet, const struct FTypedElementDeletionOptions& InDeletionOptions);
	struct FScriptTypedElementHandle DuplicateElement(const struct FScriptTypedElementHandle& InElementHandle, class UWorld* InWorld, const struct FVector& InLocationOffset);
	bool GetBounds(const struct FScriptTypedElementHandle& InElementHandle, struct FBoxSphereBounds* OutBounds);
	class ULevel* GetOwnerLevel(const struct FScriptTypedElementHandle& InElementHandle);
	class UWorld* GetOwnerWorld(const struct FScriptTypedElementHandle& InElementHandle);
	bool GetPivotOffset(const struct FScriptTypedElementHandle& InElementHandle, struct FVector* OutPivotOffset);
	bool GetRelativeTransform(const struct FScriptTypedElementHandle& InElementHandle, struct FTransform* OutTransform);
	bool GetWorldTransform(const struct FScriptTypedElementHandle& InElementHandle, struct FTransform* OutTransform);
	bool IsTemplateElement(const struct FScriptTypedElementHandle& InElementHandle);
	void NotifyMovementEnded(const struct FScriptTypedElementHandle& InElementHandle);
	void NotifyMovementOngoing(const struct FScriptTypedElementHandle& InElementHandle);
	void NotifyMovementStarted(const struct FScriptTypedElementHandle& InElementHandle);
	struct FScriptTypedElementHandle PromoteElement(const struct FScriptTypedElementHandle& InElementHandle, class UWorld* OverrideWorld);
	bool SetPivotOffset(const struct FScriptTypedElementHandle& InElementHandle, const struct FVector& InPivotOffset);
	bool SetRelativeTransform(const struct FScriptTypedElementHandle& InElementHandle, const struct FTransform& InTransform);
	bool SetWorldTransform(const struct FScriptTypedElementHandle& InElementHandle, const struct FTransform& InTransform);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"TypedElementWorldInterface">();
	}
	static class ITypedElementWorldInterface* GetDefaultObj()
	{
		return GetDefaultObjImpl<ITypedElementWorldInterface>();
	}

	class UObject* AsUObject()
	{
		return reinterpret_cast<UObject*>(this);
	}
	const class UObject* AsUObject() const
	{
		return reinterpret_cast<const UObject*>(this);
	}
};
static_assert(alignof(ITypedElementWorldInterface) == 0x000001, "Wrong alignment on ITypedElementWorldInterface");
static_assert(sizeof(ITypedElementWorldInterface) == 0x000001, "Wrong size on ITypedElementWorldInterface");

// Class Engine.ObjectElementObjectInterface
// 0x0008 (0x0030 - 0x0028)
class UObjectElementObjectInterface final : public UObject
{
public:
	uint8                                         Pad_28[0x8];                                       // 0x0028(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ObjectElementObjectInterface">();
	}
	static class UObjectElementObjectInterface* GetDefaultObj()
	{
		return GetDefaultObjImpl<UObjectElementObjectInterface>();
	}
};
static_assert(alignof(UObjectElementObjectInterface) == 0x000008, "Wrong alignment on UObjectElementObjectInterface");
static_assert(sizeof(UObjectElementObjectInterface) == 0x000030, "Wrong size on UObjectElementObjectInterface");

// Class Engine.SMInstanceElementHierarchyInterface
// 0x0008 (0x0030 - 0x0028)
class USMInstanceElementHierarchyInterface final : public UObject
{
public:
	uint8                                         Pad_28[0x8];                                       // 0x0028(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"SMInstanceElementHierarchyInterface">();
	}
	static class USMInstanceElementHierarchyInterface* GetDefaultObj()
	{
		return GetDefaultObjImpl<USMInstanceElementHierarchyInterface>();
	}
};
static_assert(alignof(USMInstanceElementHierarchyInterface) == 0x000008, "Wrong alignment on USMInstanceElementHierarchyInterface");
static_assert(sizeof(USMInstanceElementHierarchyInterface) == 0x000030, "Wrong size on USMInstanceElementHierarchyInterface");

// Class Engine.SMInstanceElementIdMapTransactor
// 0x0000 (0x0028 - 0x0028)
class USMInstanceElementIdMapTransactor final : public UObject
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"SMInstanceElementIdMapTransactor">();
	}
	static class USMInstanceElementIdMapTransactor* GetDefaultObj()
	{
		return GetDefaultObjImpl<USMInstanceElementIdMapTransactor>();
	}
};
static_assert(alignof(USMInstanceElementIdMapTransactor) == 0x000008, "Wrong alignment on USMInstanceElementIdMapTransactor");
static_assert(sizeof(USMInstanceElementIdMapTransactor) == 0x000028, "Wrong size on USMInstanceElementIdMapTransactor");

// Class Engine.LocalMessage
// 0x0000 (0x0028 - 0x0028)
class ULocalMessage : public UObject
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"LocalMessage">();
	}
	static class ULocalMessage* GetDefaultObj()
	{
		return GetDefaultObjImpl<ULocalMessage>();
	}
};
static_assert(alignof(ULocalMessage) == 0x000008, "Wrong alignment on ULocalMessage");
static_assert(sizeof(ULocalMessage) == 0x000028, "Wrong size on ULocalMessage");

// Class Engine.EngineMessage
// 0x0080 (0x00A8 - 0x0028)
class UEngineMessage final : public ULocalMessage
{
public:
	class FString                                 FailedPlaceMessage;                                // 0x0028(0x0010)(ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FString                                 MaxedOutMessage;                                   // 0x0038(0x0010)(ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FString                                 EnteredMessage;                                    // 0x0048(0x0010)(ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FString                                 LeftMessage;                                       // 0x0058(0x0010)(ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FString                                 GlobalNameChange;                                  // 0x0068(0x0010)(ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FString                                 SpecEnteredMessage;                                // 0x0078(0x0010)(ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FString                                 NewPlayerMessage;                                  // 0x0088(0x0010)(ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FString                                 NewSpecMessage;                                    // 0x0098(0x0010)(ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"EngineMessage">();
	}
	static class UEngineMessage* GetDefaultObj()
	{
		return GetDefaultObjImpl<UEngineMessage>();
	}
};
static_assert(alignof(UEngineMessage) == 0x000008, "Wrong alignment on UEngineMessage");
static_assert(sizeof(UEngineMessage) == 0x0000A8, "Wrong size on UEngineMessage");
static_assert(offsetof(UEngineMessage, FailedPlaceMessage) == 0x000028, "Member 'UEngineMessage::FailedPlaceMessage' has a wrong offset!");
static_assert(offsetof(UEngineMessage, MaxedOutMessage) == 0x000038, "Member 'UEngineMessage::MaxedOutMessage' has a wrong offset!");
static_assert(offsetof(UEngineMessage, EnteredMessage) == 0x000048, "Member 'UEngineMessage::EnteredMessage' has a wrong offset!");
static_assert(offsetof(UEngineMessage, LeftMessage) == 0x000058, "Member 'UEngineMessage::LeftMessage' has a wrong offset!");
static_assert(offsetof(UEngineMessage, GlobalNameChange) == 0x000068, "Member 'UEngineMessage::GlobalNameChange' has a wrong offset!");
static_assert(offsetof(UEngineMessage, SpecEnteredMessage) == 0x000078, "Member 'UEngineMessage::SpecEnteredMessage' has a wrong offset!");
static_assert(offsetof(UEngineMessage, NewPlayerMessage) == 0x000088, "Member 'UEngineMessage::NewPlayerMessage' has a wrong offset!");
static_assert(offsetof(UEngineMessage, NewSpecMessage) == 0x000098, "Member 'UEngineMessage::NewSpecMessage' has a wrong offset!");

// Class Engine.LODSyncInterface
// 0x0000 (0x0000 - 0x0000)
class ILODSyncInterface final
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"LODSyncInterface">();
	}
	static class ILODSyncInterface* GetDefaultObj()
	{
		return GetDefaultObjImpl<ILODSyncInterface>();
	}

	class UObject* AsUObject()
	{
		return reinterpret_cast<UObject*>(this);
	}
	const class UObject* AsUObject() const
	{
		return reinterpret_cast<const UObject*>(this);
	}
};
static_assert(alignof(ILODSyncInterface) == 0x000001, "Wrong alignment on ILODSyncInterface");
static_assert(sizeof(ILODSyncInterface) == 0x000001, "Wrong size on ILODSyncInterface");

// Class Engine.PoseWatch
// 0x0000 (0x0028 - 0x0028)
class UPoseWatch final : public UObject
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"PoseWatch">();
	}
	static class UPoseWatch* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPoseWatch>();
	}
};
static_assert(alignof(UPoseWatch) == 0x000008, "Wrong alignment on UPoseWatch");
static_assert(sizeof(UPoseWatch) == 0x000028, "Wrong size on UPoseWatch");

// Class Engine.ViewportStatsSubsystem
// 0x0020 (0x0050 - 0x0030)
class UViewportStatsSubsystem final : public UWorldSubsystem
{
public:
	uint8                                         Pad_30[0x20];                                      // 0x0030(0x0020)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	int32 AddDisplayDelegate(const TDelegate<void(class FText* OutText, struct FLinearColor* OutColor)>& Delegate);
	void AddTimedDisplay(const class FText& Text, const struct FLinearColor& Color, float Duration, const struct FVector2D& DisplayOffset);
	void RemoveDisplayDelegate(const int32 IndexToRemove);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ViewportStatsSubsystem">();
	}
	static class UViewportStatsSubsystem* GetDefaultObj()
	{
		return GetDefaultObjImpl<UViewportStatsSubsystem>();
	}
};
static_assert(alignof(UViewportStatsSubsystem) == 0x000008, "Wrong alignment on UViewportStatsSubsystem");
static_assert(sizeof(UViewportStatsSubsystem) == 0x000050, "Wrong size on UViewportStatsSubsystem");

// Class Engine.FloatingPawnMovement
// 0x0018 (0x0178 - 0x0160)
class UFloatingPawnMovement : public UPawnMovementComponent
{
public:
	float                                         MaxSpeed;                                          // 0x0160(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         Acceleration;                                      // 0x0164(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         Deceleration;                                      // 0x0168(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         TurningBoost;                                      // 0x016C(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bPositionCorrected : 1;                            // 0x0170(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Transient, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected))
	uint8                                         Pad_171[0x7];                                      // 0x0171(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"FloatingPawnMovement">();
	}
	static class UFloatingPawnMovement* GetDefaultObj()
	{
		return GetDefaultObjImpl<UFloatingPawnMovement>();
	}
};
static_assert(alignof(UFloatingPawnMovement) == 0x000008, "Wrong alignment on UFloatingPawnMovement");
static_assert(sizeof(UFloatingPawnMovement) == 0x000178, "Wrong size on UFloatingPawnMovement");
static_assert(offsetof(UFloatingPawnMovement, MaxSpeed) == 0x000160, "Member 'UFloatingPawnMovement::MaxSpeed' has a wrong offset!");
static_assert(offsetof(UFloatingPawnMovement, Acceleration) == 0x000164, "Member 'UFloatingPawnMovement::Acceleration' has a wrong offset!");
static_assert(offsetof(UFloatingPawnMovement, Deceleration) == 0x000168, "Member 'UFloatingPawnMovement::Deceleration' has a wrong offset!");
static_assert(offsetof(UFloatingPawnMovement, TurningBoost) == 0x00016C, "Member 'UFloatingPawnMovement::TurningBoost' has a wrong offset!");

// Class Engine.Font
// 0x01A8 (0x01D0 - 0x0028)
class UFont final : public UObject
{
public:
	uint8                                         Pad_28[0x8];                                       // 0x0028(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	EFontCacheType                                FontCacheType;                                     // 0x0030(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_31[0x7];                                       // 0x0031(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<struct FFontCharacter>                 Characters;                                        // 0x0038(0x0010)(Edit, ZeroConstructor, NativeAccessSpecifierPublic)
	TArray<class UTexture2D*>                     Textures;                                          // 0x0048(0x0010)(ZeroConstructor, UObjectWrapper, NativeAccessSpecifierPublic)
	int32                                         IsRemapped;                                        // 0x0058(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         EmScale;                                           // 0x005C(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         Ascent;                                            // 0x0060(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         Descent;                                           // 0x0064(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         Leading;                                           // 0x0068(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         Kerning;                                           // 0x006C(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FFontImportOptionsData                 ImportOptions;                                     // 0x0070(0x00B0)(Edit, NativeAccessSpecifierPublic)
	int32                                         NumCharacters;                                     // 0x0120(0x0004)(ZeroConstructor, Transient, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_124[0x4];                                      // 0x0124(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<int32>                                 MaxCharHeight;                                     // 0x0128(0x0010)(ZeroConstructor, Transient, NativeAccessSpecifierPublic)
	float                                         ScalingFactor;                                     // 0x0138(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         LegacyFontSize;                                    // 0x013C(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FName                                   LegacyFontName;                                    // 0x0140(0x0008)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FCompositeFont                         CompositeFont;                                     // 0x0148(0x0038)(NativeAccessSpecifierPublic)
	uint8                                         Pad_180[0x50];                                     // 0x0180(0x0050)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"Font">();
	}
	static class UFont* GetDefaultObj()
	{
		return GetDefaultObjImpl<UFont>();
	}
};
static_assert(alignof(UFont) == 0x000008, "Wrong alignment on UFont");
static_assert(sizeof(UFont) == 0x0001D0, "Wrong size on UFont");
static_assert(offsetof(UFont, FontCacheType) == 0x000030, "Member 'UFont::FontCacheType' has a wrong offset!");
static_assert(offsetof(UFont, Characters) == 0x000038, "Member 'UFont::Characters' has a wrong offset!");
static_assert(offsetof(UFont, Textures) == 0x000048, "Member 'UFont::Textures' has a wrong offset!");
static_assert(offsetof(UFont, IsRemapped) == 0x000058, "Member 'UFont::IsRemapped' has a wrong offset!");
static_assert(offsetof(UFont, EmScale) == 0x00005C, "Member 'UFont::EmScale' has a wrong offset!");
static_assert(offsetof(UFont, Ascent) == 0x000060, "Member 'UFont::Ascent' has a wrong offset!");
static_assert(offsetof(UFont, Descent) == 0x000064, "Member 'UFont::Descent' has a wrong offset!");
static_assert(offsetof(UFont, Leading) == 0x000068, "Member 'UFont::Leading' has a wrong offset!");
static_assert(offsetof(UFont, Kerning) == 0x00006C, "Member 'UFont::Kerning' has a wrong offset!");
static_assert(offsetof(UFont, ImportOptions) == 0x000070, "Member 'UFont::ImportOptions' has a wrong offset!");
static_assert(offsetof(UFont, NumCharacters) == 0x000120, "Member 'UFont::NumCharacters' has a wrong offset!");
static_assert(offsetof(UFont, MaxCharHeight) == 0x000128, "Member 'UFont::MaxCharHeight' has a wrong offset!");
static_assert(offsetof(UFont, ScalingFactor) == 0x000138, "Member 'UFont::ScalingFactor' has a wrong offset!");
static_assert(offsetof(UFont, LegacyFontSize) == 0x00013C, "Member 'UFont::LegacyFontSize' has a wrong offset!");
static_assert(offsetof(UFont, LegacyFontName) == 0x000140, "Member 'UFont::LegacyFontName' has a wrong offset!");
static_assert(offsetof(UFont, CompositeFont) == 0x000148, "Member 'UFont::CompositeFont' has a wrong offset!");

// Class Engine.AsyncActionHandleSaveGame
// 0x0038 (0x0068 - 0x0030)
class UAsyncActionHandleSaveGame final : public UBlueprintAsyncActionBase
{
public:
	TMulticastInlineDelegate<void(class USaveGame* SaveGame, bool bSuccess)> Completed;              // 0x0030(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	uint8                                         Pad_40[0x20];                                      // 0x0040(0x0020)(Fixing Size After Last Property [ Dumper-7 ])
	class USaveGame*                              SaveGameObject;                                    // 0x0060(0x0008)(ZeroConstructor, NoDestructor, Protected, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierProtected)

public:
	static class UAsyncActionHandleSaveGame* AsyncLoadGameFromSlot(class UObject* WorldContextObject, const class FString& SlotName, const int32 UserIndex);
	static class UAsyncActionHandleSaveGame* AsyncSaveGameToSlot(class UObject* WorldContextObject, class USaveGame* SaveGameObject_0, const class FString& SlotName, const int32 UserIndex);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AsyncActionHandleSaveGame">();
	}
	static class UAsyncActionHandleSaveGame* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAsyncActionHandleSaveGame>();
	}
};
static_assert(alignof(UAsyncActionHandleSaveGame) == 0x000008, "Wrong alignment on UAsyncActionHandleSaveGame");
static_assert(sizeof(UAsyncActionHandleSaveGame) == 0x000068, "Wrong size on UAsyncActionHandleSaveGame");
static_assert(offsetof(UAsyncActionHandleSaveGame, Completed) == 0x000030, "Member 'UAsyncActionHandleSaveGame::Completed' has a wrong offset!");
static_assert(offsetof(UAsyncActionHandleSaveGame, SaveGameObject) == 0x000060, "Member 'UAsyncActionHandleSaveGame::SaveGameObject' has a wrong offset!");

// Class Engine.ColorInputDeviceProperty
// 0x0068 (0x0098 - 0x0030)
class UColorInputDeviceProperty final : public UInputDeviceProperty
{
public:
	struct FDeviceColorData                       ColorData;                                         // 0x0030(0x0008)(Edit, BlueprintVisible, NoDestructor, NativeAccessSpecifierPublic)
	TMap<class FName, struct FDeviceColorData>    DeviceOverrideData;                                // 0x0038(0x0050)(Edit, BlueprintVisible, NativeAccessSpecifierPublic)
	uint8                                         Pad_88[0x10];                                      // 0x0088(0x0010)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ColorInputDeviceProperty">();
	}
	static class UColorInputDeviceProperty* GetDefaultObj()
	{
		return GetDefaultObjImpl<UColorInputDeviceProperty>();
	}
};
static_assert(alignof(UColorInputDeviceProperty) == 0x000008, "Wrong alignment on UColorInputDeviceProperty");
static_assert(sizeof(UColorInputDeviceProperty) == 0x000098, "Wrong size on UColorInputDeviceProperty");
static_assert(offsetof(UColorInputDeviceProperty, ColorData) == 0x000030, "Member 'UColorInputDeviceProperty::ColorData' has a wrong offset!");
static_assert(offsetof(UColorInputDeviceProperty, DeviceOverrideData) == 0x000038, "Member 'UColorInputDeviceProperty::DeviceOverrideData' has a wrong offset!");

// Class Engine.ColorInputDeviceCurveProperty
// 0x0070 (0x00A0 - 0x0030)
class UColorInputDeviceCurveProperty final : public UInputDeviceProperty
{
public:
	struct FDeviceColorCurveData                  ColorData;                                         // 0x0030(0x0010)(Edit, BlueprintVisible, NoDestructor, Protected, NativeAccessSpecifierProtected)
	TMap<class FName, struct FDeviceColorCurveData> DeviceOverrideData;                              // 0x0040(0x0050)(Edit, BlueprintVisible, Protected, NativeAccessSpecifierProtected)
	uint8                                         Pad_90[0x10];                                      // 0x0090(0x0010)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ColorInputDeviceCurveProperty">();
	}
	static class UColorInputDeviceCurveProperty* GetDefaultObj()
	{
		return GetDefaultObjImpl<UColorInputDeviceCurveProperty>();
	}
};
static_assert(alignof(UColorInputDeviceCurveProperty) == 0x000008, "Wrong alignment on UColorInputDeviceCurveProperty");
static_assert(sizeof(UColorInputDeviceCurveProperty) == 0x0000A0, "Wrong size on UColorInputDeviceCurveProperty");
static_assert(offsetof(UColorInputDeviceCurveProperty, ColorData) == 0x000030, "Member 'UColorInputDeviceCurveProperty::ColorData' has a wrong offset!");
static_assert(offsetof(UColorInputDeviceCurveProperty, DeviceOverrideData) == 0x000040, "Member 'UColorInputDeviceCurveProperty::DeviceOverrideData' has a wrong offset!");

// Class Engine.InputDeviceTriggerResistanceProperty
// 0x0080 (0x00C0 - 0x0040)
class UInputDeviceTriggerResistanceProperty final : public UInputDeviceTriggerEffect
{
public:
	struct FDeviceTriggerTriggerResistanceData    TriggerData;                                       // 0x0040(0x0010)(Edit, BlueprintVisible, NoDestructor, Protected, NativeAccessSpecifierProtected)
	TMap<class FName, struct FDeviceTriggerTriggerResistanceData> DeviceOverrideData;                // 0x0050(0x0050)(Edit, BlueprintVisible, Protected, NativeAccessSpecifierProtected)
	uint8                                         Pad_A0[0x20];                                      // 0x00A0(0x0020)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"InputDeviceTriggerResistanceProperty">();
	}
	static class UInputDeviceTriggerResistanceProperty* GetDefaultObj()
	{
		return GetDefaultObjImpl<UInputDeviceTriggerResistanceProperty>();
	}
};
static_assert(alignof(UInputDeviceTriggerResistanceProperty) == 0x000008, "Wrong alignment on UInputDeviceTriggerResistanceProperty");
static_assert(sizeof(UInputDeviceTriggerResistanceProperty) == 0x0000C0, "Wrong size on UInputDeviceTriggerResistanceProperty");
static_assert(offsetof(UInputDeviceTriggerResistanceProperty, TriggerData) == 0x000040, "Member 'UInputDeviceTriggerResistanceProperty::TriggerData' has a wrong offset!");
static_assert(offsetof(UInputDeviceTriggerResistanceProperty, DeviceOverrideData) == 0x000050, "Member 'UInputDeviceTriggerResistanceProperty::DeviceOverrideData' has a wrong offset!");

// Class Engine.InputDeviceTriggerVibrationProperty
// 0x0080 (0x00C0 - 0x0040)
class UInputDeviceTriggerVibrationProperty final : public UInputDeviceTriggerEffect
{
public:
	struct FDeviceTriggerTriggerVibrationData     TriggerData;                                       // 0x0040(0x0018)(Edit, BlueprintVisible, NoDestructor, NativeAccessSpecifierPublic)
	TMap<class FName, struct FDeviceTriggerTriggerVibrationData> DeviceOverrideData;                 // 0x0058(0x0050)(Edit, BlueprintVisible, NativeAccessSpecifierPublic)
	uint8                                         Pad_A8[0x18];                                      // 0x00A8(0x0018)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"InputDeviceTriggerVibrationProperty">();
	}
	static class UInputDeviceTriggerVibrationProperty* GetDefaultObj()
	{
		return GetDefaultObjImpl<UInputDeviceTriggerVibrationProperty>();
	}
};
static_assert(alignof(UInputDeviceTriggerVibrationProperty) == 0x000008, "Wrong alignment on UInputDeviceTriggerVibrationProperty");
static_assert(sizeof(UInputDeviceTriggerVibrationProperty) == 0x0000C0, "Wrong size on UInputDeviceTriggerVibrationProperty");
static_assert(offsetof(UInputDeviceTriggerVibrationProperty, TriggerData) == 0x000040, "Member 'UInputDeviceTriggerVibrationProperty::TriggerData' has a wrong offset!");
static_assert(offsetof(UInputDeviceTriggerVibrationProperty, DeviceOverrideData) == 0x000058, "Member 'UInputDeviceTriggerVibrationProperty::DeviceOverrideData' has a wrong offset!");

// Class Engine.InputDeviceAudioBasedVibrationProperty
// 0x0058 (0x0088 - 0x0030)
class UInputDeviceAudioBasedVibrationProperty final : public UInputDeviceProperty
{
public:
	struct FAudioBasedVibrationData               Data;                                              // 0x0030(0x0008)(Edit, BlueprintVisible, NoDestructor, NativeAccessSpecifierPublic)
	TMap<class FName, struct FAudioBasedVibrationData> DeviceOverrideData;                           // 0x0038(0x0050)(Edit, BlueprintVisible, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"InputDeviceAudioBasedVibrationProperty">();
	}
	static class UInputDeviceAudioBasedVibrationProperty* GetDefaultObj()
	{
		return GetDefaultObjImpl<UInputDeviceAudioBasedVibrationProperty>();
	}
};
static_assert(alignof(UInputDeviceAudioBasedVibrationProperty) == 0x000008, "Wrong alignment on UInputDeviceAudioBasedVibrationProperty");
static_assert(sizeof(UInputDeviceAudioBasedVibrationProperty) == 0x000088, "Wrong size on UInputDeviceAudioBasedVibrationProperty");
static_assert(offsetof(UInputDeviceAudioBasedVibrationProperty, Data) == 0x000030, "Member 'UInputDeviceAudioBasedVibrationProperty::Data' has a wrong offset!");
static_assert(offsetof(UInputDeviceAudioBasedVibrationProperty, DeviceOverrideData) == 0x000038, "Member 'UInputDeviceAudioBasedVibrationProperty::DeviceOverrideData' has a wrong offset!");

// Class Engine.LocalPlayerSaveGame
// 0x0030 (0x0058 - 0x0028)
class ULocalPlayerSaveGame final : public USaveGame
{
public:
	class ULocalPlayer*                           OwningPlayer;                                      // 0x0028(0x0008)(ZeroConstructor, Transient, NoDestructor, Protected, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	class FString                                 SaveSlotName;                                      // 0x0030(0x0010)(ZeroConstructor, Transient, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	int32                                         SavedDataVersion;                                  // 0x0040(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	int32                                         LoadedDataVersion;                                 // 0x0044(0x0004)(ZeroConstructor, Transient, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	int32                                         CurrentSaveRequest;                                // 0x0048(0x0004)(ZeroConstructor, Transient, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	int32                                         LastSuccessfulSaveRequest;                         // 0x004C(0x0004)(ZeroConstructor, Transient, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	int32                                         LastErrorSaveRequest;                              // 0x0050(0x0004)(ZeroConstructor, Transient, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_54[0x4];                                       // 0x0054(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static bool AsyncLoadOrCreateSaveGameForLocalPlayer(TSubclassOf<class ULocalPlayerSaveGame> SaveGameClass, class APlayerController* LocalPlayerController, const class FString& SlotName, TDelegate<void(class ULocalPlayerSaveGame* SaveGame)> Delegate);
	static class ULocalPlayerSaveGame* LoadOrCreateSaveGameForLocalPlayer(TSubclassOf<class ULocalPlayerSaveGame> SaveGameClass, class APlayerController* LocalPlayerController, const class FString& SlotName);

	bool AsyncSaveGameToSlotForLocalPlayer();
	void OnPostLoad();
	void OnPostSave(bool bSuccess);
	void OnPreSave();
	void OnResetToDefault();
	void ResetToDefault();
	bool SaveGameToSlotForLocalPlayer();

	int32 GetInvalidDataVersion() const;
	int32 GetLatestDataVersion() const;
	class APlayerController* GetLocalPlayerController() const;
	struct FPlatformUserId GetPlatformUserId() const;
	int32 GetPlatformUserIndex() const;
	int32 GetSavedDataVersion() const;
	class FString GetSaveSlotName() const;
	bool IsSaveInProgress() const;
	bool WasLastSaveSuccessful() const;
	bool WasLoaded() const;
	bool WasSaveRequested() const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"LocalPlayerSaveGame">();
	}
	static class ULocalPlayerSaveGame* GetDefaultObj()
	{
		return GetDefaultObjImpl<ULocalPlayerSaveGame>();
	}
};
static_assert(alignof(ULocalPlayerSaveGame) == 0x000008, "Wrong alignment on ULocalPlayerSaveGame");
static_assert(sizeof(ULocalPlayerSaveGame) == 0x000058, "Wrong size on ULocalPlayerSaveGame");
static_assert(offsetof(ULocalPlayerSaveGame, OwningPlayer) == 0x000028, "Member 'ULocalPlayerSaveGame::OwningPlayer' has a wrong offset!");
static_assert(offsetof(ULocalPlayerSaveGame, SaveSlotName) == 0x000030, "Member 'ULocalPlayerSaveGame::SaveSlotName' has a wrong offset!");
static_assert(offsetof(ULocalPlayerSaveGame, SavedDataVersion) == 0x000040, "Member 'ULocalPlayerSaveGame::SavedDataVersion' has a wrong offset!");
static_assert(offsetof(ULocalPlayerSaveGame, LoadedDataVersion) == 0x000044, "Member 'ULocalPlayerSaveGame::LoadedDataVersion' has a wrong offset!");
static_assert(offsetof(ULocalPlayerSaveGame, CurrentSaveRequest) == 0x000048, "Member 'ULocalPlayerSaveGame::CurrentSaveRequest' has a wrong offset!");
static_assert(offsetof(ULocalPlayerSaveGame, LastSuccessfulSaveRequest) == 0x00004C, "Member 'ULocalPlayerSaveGame::LastSuccessfulSaveRequest' has a wrong offset!");
static_assert(offsetof(ULocalPlayerSaveGame, LastErrorSaveRequest) == 0x000050, "Member 'ULocalPlayerSaveGame::LastErrorSaveRequest' has a wrong offset!");

// Class Engine.TouchInterface
// 0x0030 (0x0058 - 0x0028)
class UTouchInterface final : public UObject
{
public:
	TArray<struct FTouchInputControl>             Controls;                                          // 0x0028(0x0010)(Edit, ZeroConstructor, NativeAccessSpecifierPublic)
	float                                         ActiveOpacity;                                     // 0x0038(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         InactiveOpacity;                                   // 0x003C(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         TimeUntilDeactive;                                 // 0x0040(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         TimeUntilReset;                                    // 0x0044(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         ActivationDelay;                                   // 0x0048(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bPreventRecenter;                                  // 0x004C(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_4D[0x3];                                       // 0x004D(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         StartupDelay;                                      // 0x0050(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_54[0x4];                                       // 0x0054(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"TouchInterface">();
	}
	static class UTouchInterface* GetDefaultObj()
	{
		return GetDefaultObjImpl<UTouchInterface>();
	}
};
static_assert(alignof(UTouchInterface) == 0x000008, "Wrong alignment on UTouchInterface");
static_assert(sizeof(UTouchInterface) == 0x000058, "Wrong size on UTouchInterface");
static_assert(offsetof(UTouchInterface, Controls) == 0x000028, "Member 'UTouchInterface::Controls' has a wrong offset!");
static_assert(offsetof(UTouchInterface, ActiveOpacity) == 0x000038, "Member 'UTouchInterface::ActiveOpacity' has a wrong offset!");
static_assert(offsetof(UTouchInterface, InactiveOpacity) == 0x00003C, "Member 'UTouchInterface::InactiveOpacity' has a wrong offset!");
static_assert(offsetof(UTouchInterface, TimeUntilDeactive) == 0x000040, "Member 'UTouchInterface::TimeUntilDeactive' has a wrong offset!");
static_assert(offsetof(UTouchInterface, TimeUntilReset) == 0x000044, "Member 'UTouchInterface::TimeUntilReset' has a wrong offset!");
static_assert(offsetof(UTouchInterface, ActivationDelay) == 0x000048, "Member 'UTouchInterface::ActivationDelay' has a wrong offset!");
static_assert(offsetof(UTouchInterface, bPreventRecenter) == 0x00004C, "Member 'UTouchInterface::bPreventRecenter' has a wrong offset!");
static_assert(offsetof(UTouchInterface, StartupDelay) == 0x000050, "Member 'UTouchInterface::StartupDelay' has a wrong offset!");

// Class Engine.GameInstance
// 0x0198 (0x01C0 - 0x0028)
class UGameInstance : public UObject
{
public:
	uint8                                         Pad_28[0x10];                                      // 0x0028(0x0010)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<class ULocalPlayer*>                   LocalPlayers;                                      // 0x0038(0x0010)(ZeroConstructor, Protected, UObjectWrapper, NativeAccessSpecifierProtected)
	class UOnlineSession*                         OnlineSession;                                     // 0x0048(0x0008)(ZeroConstructor, NoDestructor, Protected, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	TArray<class UObject*>                        ReferencedObjects;                                 // 0x0050(0x0010)(ZeroConstructor, Protected, UObjectWrapper, NativeAccessSpecifierProtected)
	uint8                                         Pad_60[0x18];                                      // 0x0060(0x0018)(Fixing Size After Last Property [ Dumper-7 ])
	TMulticastInlineDelegate<void(class APawn* Pawn, class AController* Controller)> OnPawnControllerChangedDelegates; // 0x0078(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, Protected, NativeAccessSpecifierProtected)
	uint8                                         Pad_88[0x18];                                      // 0x0088(0x0018)(Fixing Size After Last Property [ Dumper-7 ])
	TMulticastInlineDelegate<void(EInputDeviceConnectionState NewConnectionState, const struct FPlatformUserId& PlatformUserId, const struct FInputDeviceId& InputDeviceId)> OnInputDeviceConnectionChange; // 0x00A0(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	TMulticastInlineDelegate<void(const struct FInputDeviceId& InputDeviceId, const struct FPlatformUserId& NewUserPlatformId, const struct FPlatformUserId& OldUserPlatformId)> OnUserInputDevicePairingChange; // 0x00B0(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	uint8                                         Pad_C0[0x100];                                     // 0x00C0(0x0100)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void DebugCreatePlayer(int32 ControllerId);
	void DebugRemovePlayer(int32 ControllerId);
	void HandleNetworkError(ENetworkFailure FailureType, bool bIsServer);
	void HandleTravelError(ETravelFailure FailureType);
	void ReceiveInit();
	void ReceiveShutdown();

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"GameInstance">();
	}
	static class UGameInstance* GetDefaultObj()
	{
		return GetDefaultObjImpl<UGameInstance>();
	}
};
static_assert(alignof(UGameInstance) == 0x000008, "Wrong alignment on UGameInstance");
static_assert(sizeof(UGameInstance) == 0x0001C0, "Wrong size on UGameInstance");
static_assert(offsetof(UGameInstance, LocalPlayers) == 0x000038, "Member 'UGameInstance::LocalPlayers' has a wrong offset!");
static_assert(offsetof(UGameInstance, OnlineSession) == 0x000048, "Member 'UGameInstance::OnlineSession' has a wrong offset!");
static_assert(offsetof(UGameInstance, ReferencedObjects) == 0x000050, "Member 'UGameInstance::ReferencedObjects' has a wrong offset!");
static_assert(offsetof(UGameInstance, OnPawnControllerChangedDelegates) == 0x000078, "Member 'UGameInstance::OnPawnControllerChangedDelegates' has a wrong offset!");
static_assert(offsetof(UGameInstance, OnInputDeviceConnectionChange) == 0x0000A0, "Member 'UGameInstance::OnInputDeviceConnectionChange' has a wrong offset!");
static_assert(offsetof(UGameInstance, OnUserInputDevicePairingChange) == 0x0000B0, "Member 'UGameInstance::OnUserInputDevicePairingChange' has a wrong offset!");

// Class Engine.GameplayStatics
// 0x0000 (0x0028 - 0x0028)
class UGameplayStatics final : public UBlueprintFunctionLibrary
{
public:
	static void ActivateReverbEffect(const class UObject* WorldContextObject, class UReverbEffect* ReverbEffect, class FName TagName, float Priority, float Volume, float FadeTime);
	static void AnnounceAccessibleString(const class FString& AnnouncementString);
	static float ApplyDamage(class AActor* DamagedActor, float BaseDamage, class AController* EventInstigator, class AActor* DamageCauser, TSubclassOf<class UDamageType> DamageTypeClass);
	static float ApplyPointDamage(class AActor* DamagedActor, float BaseDamage, const struct FVector& HitFromDirection, const struct FHitResult& HitInfo, class AController* EventInstigator, class AActor* DamageCauser, TSubclassOf<class UDamageType> DamageTypeClass);
	static bool ApplyRadialDamage(const class UObject* WorldContextObject, float BaseDamage, const struct FVector& Origin, float DamageRadius, TSubclassOf<class UDamageType> DamageTypeClass, const TArray<class AActor*>& IgnoreActors, class AActor* DamageCauser, class AController* InstigatedByController, bool bDoFullDamage, ECollisionChannel DamagePreventionChannel);
	static bool ApplyRadialDamageWithFalloff(const class UObject* WorldContextObject, float BaseDamage, float MinimumDamage, const struct FVector& Origin, float DamageInnerRadius, float DamageOuterRadius, float DamageFalloff, TSubclassOf<class UDamageType> DamageTypeClass, const TArray<class AActor*>& IgnoreActors, class AActor* DamageCauser, class AController* InstigatedByController, ECollisionChannel DamagePreventionChannel);
	static bool AreAnyListenersWithinRange(const class UObject* WorldContextObject, const struct FVector& Location, float MaximumRange);
	static bool AreSubtitlesEnabled();
	static class AActor* BeginDeferredActorSpawnFromClass(const class UObject* WorldContextObject, TSubclassOf<class AActor> ActorClass, const struct FTransform& SpawnTransform, ESpawnActorCollisionHandlingMethod CollisionHandlingOverride, class AActor* Owner, ESpawnActorScaleMethod TransformScaleMethod);
	static class AActor* BeginSpawningActorFromBlueprint(const class UObject* WorldContextObject, const class UBlueprint* Blueprint, const struct FTransform& SpawnTransform, bool bNoCollisionFail);
	static bool Blueprint_PredictProjectilePath_Advanced(const class UObject* WorldContextObject, const struct FPredictProjectilePathParams& PredictParams, struct FPredictProjectilePathResult* PredictResult);
	static bool Blueprint_PredictProjectilePath_ByObjectType(const class UObject* WorldContextObject, struct FHitResult* OutHit, TArray<struct FVector>* OutPathPositions, struct FVector* OutLastTraceDestination, const struct FVector& StartPos, const struct FVector& LaunchVelocity, bool bTracePath, float ProjectileRadius, const TArray<EObjectTypeQuery>& ObjectTypes, bool bTraceComplex, const TArray<class AActor*>& ActorsToIgnore, EDrawDebugTrace DrawDebugType, float DrawDebugTime, float SimFrequency, float MaxSimTime, float OverrideGravityZ);
	static bool Blueprint_PredictProjectilePath_ByTraceChannel(const class UObject* WorldContextObject, struct FHitResult* OutHit, TArray<struct FVector>* OutPathPositions, struct FVector* OutLastTraceDestination, const struct FVector& StartPos, const struct FVector& LaunchVelocity, bool bTracePath, float ProjectileRadius, ECollisionChannel TraceChannel, bool bTraceComplex, const TArray<class AActor*>& ActorsToIgnore, EDrawDebugTrace DrawDebugType, float DrawDebugTime, float SimFrequency, float MaxSimTime, float OverrideGravityZ);
	static bool BlueprintSuggestProjectileVelocity(const class UObject* WorldContextObject, struct FVector* TossVelocity, const struct FVector& StartLocation, const struct FVector& EndLocation, float LaunchSpeed, float OverrideGravityZ, ESuggestProjVelocityTraceOption TraceOption, float CollisionRadius, bool bFavorHighArc, bool bDrawDebug);
	static void BreakHitResult(const struct FHitResult& Hit, bool* bBlockingHit, bool* bInitialOverlap, float* Time, float* Distance, struct FVector* Location, struct FVector* ImpactPoint, struct FVector* Normal, struct FVector* ImpactNormal, class UPhysicalMaterial** PhysMat, class AActor** HitActor, class UPrimitiveComponent** HitComponent, class FName* HitBoneName, class FName* BoneName, int32* HitItem, int32* ElementIndex, int32* FaceIndex, struct FVector* TraceStart, struct FVector* TraceEnd);
	static void CancelAsyncLoading();
	static void ClearSoundMixClassOverride(const class UObject* WorldContextObject, class USoundMix* InSoundMixModifier, class USoundClass* InSoundClass, float FadeOutTime);
	static void ClearSoundMixModifiers(const class UObject* WorldContextObject);
	static class APlayerController* CreatePlayer(const class UObject* WorldContextObject, int32 ControllerId, bool bSpawnPlayerController);
	static class APlayerController* CreatePlayerFromPlatformUser(const class UObject* WorldContextObject, const struct FPlatformUserId& UserId, bool bSpawnPlayerController);
	static class USaveGame* CreateSaveGameObject(TSubclassOf<class USaveGame> SaveGameClass);
	static class UAudioComponent* CreateSound2D(const class UObject* WorldContextObject, class USoundBase* Sound, float VolumeMultiplier, float PitchMultiplier, float startTime, class USoundConcurrency* ConcurrencySettings, bool bPersistAcrossLevelTransition, bool bAutoDestroy);
	static void DeactivateReverbEffect(const class UObject* WorldContextObject, class FName TagName);
	static bool DeleteGameInSlot(const class FString& SlotName, const int32 UserIndex);
	static bool DeprojectSceneCaptureToWorld(class ASceneCapture2D* SceneCapture2D, const struct FVector2D& TargetUV, struct FVector* WorldPosition, struct FVector* WorldDirection);
	static bool DeprojectScreenToWorld(class APlayerController* Player, const struct FVector2D& ScreenPosition, struct FVector* WorldPosition, struct FVector* WorldDirection);
	static bool DoesSaveGameExist(const class FString& SlotName, const int32 UserIndex);
	static void EnableLiveStreaming(bool Enable);
	static bool FindCollisionUV(const struct FHitResult& Hit, int32 UVChannel, struct FVector2D* UV);
	static class AActor* FindNearestActor(const struct FVector& Origin, const TArray<class AActor*>& ActorsToCheck, float* Distance);
	static class AActor* FinishSpawningActor(class AActor* Actor, const struct FTransform& SpawnTransform, ESpawnActorScaleMethod TransformScaleMethod);
	static void FlushLevelStreaming(const class UObject* WorldContextObject);
	static void GetAccurateRealTime(int32* Seconds, double* PartialSeconds);
	static class FName GetActiveSpatialPluginName(const class UObject* WorldContextObject);
	static struct FVector GetActorArrayAverageLocation(const TArray<class AActor*>& Actors);
	static void GetActorArrayBounds(const TArray<class AActor*>& Actors, bool bOnlyCollidingComponents, struct FVector* Center, struct FVector* BoxExtent);
	static class AActor* GetActorOfClass(const class UObject* WorldContextObject, TSubclassOf<class AActor> ActorClass);
	static void GetAllActorsOfClass(const class UObject* WorldContextObject, TSubclassOf<class AActor> ActorClass, TArray<class AActor*>* OutActors);
	static void GetAllActorsOfClassWithTag(const class UObject* WorldContextObject, TSubclassOf<class AActor> ActorClass, class FName Tag, TArray<class AActor*>* OutActors);
	static void GetAllActorsWithInterface(const class UObject* WorldContextObject, TSubclassOf<class IInterface> Interface, TArray<class AActor*>* OutActors);
	static void GetAllActorsWithTag(const class UObject* WorldContextObject, class FName Tag, TArray<class AActor*>* OutActors);
	static double GetAudioTimeSeconds(const class UObject* WorldContextObject);
	static TArray<class FName> GetAvailableSpatialPluginNames(const class UObject* WorldContextObject);
	static bool GetClosestListenerLocation(const class UObject* WorldContextObject, const struct FVector& Location, float MaximumRange, const bool bAllowAttenuationOverride, struct FVector* ListenerPosition);
	static class FString GetCurrentLevelName(const class UObject* WorldContextObject, bool bRemovePrefixString);
	static class UReverbEffect* GetCurrentReverbEffect(const class UObject* WorldContextObject);
	static bool GetEnableWorldRendering(const class UObject* WorldContextObject);
	static class UGameInstance* GetGameInstance(const class UObject* WorldContextObject);
	static class AGameModeBase* GetGameMode(const class UObject* WorldContextObject);
	static class AGameStateBase* GetGameState(const class UObject* WorldContextObject);
	static float GetGlobalTimeDilation(const class UObject* WorldContextObject);
	static int32 GetIntOption(const class FString& OPTIONS, const class FString& Key, int32 DefaultValue);
	static void GetKeyValue(const class FString& Pair, class FString* Key, class FString* Value);
	static int32 GetMaxAudioChannelCount(const class UObject* WorldContextObject);
	static int32 GetNumLocalPlayerControllers(const class UObject* WorldContextObject);
	static int32 GetNumPlayerControllers(const class UObject* WorldContextObject);
	static int32 GetNumPlayerStates(const class UObject* WorldContextObject);
	static class UClass* GetObjectClass(const class UObject* Object);
	static class FString GetPlatformName();
	static class APlayerCameraManager* GetPlayerCameraManager(const class UObject* WorldContextObject, int32 PlayerIndex);
	static class ACharacter* GetPlayerCharacter(const class UObject* WorldContextObject, int32 PlayerIndex);
	static class APlayerController* GetPlayerController(const class UObject* WorldContextObject, int32 PlayerIndex);
	static class APlayerController* GetPlayerControllerFromID(const class UObject* WorldContextObject, int32 ControllerId);
	static class APlayerController* GetPlayerControllerFromPlatformUser(const class UObject* WorldContextObject, const struct FPlatformUserId& UserId);
	static int32 GetPlayerControllerID(class APlayerController* Player);
	static class APawn* GetPlayerPawn(const class UObject* WorldContextObject, int32 PlayerIndex);
	static class APlayerState* GetPlayerState(const class UObject* WorldContextObject, int32 PlayerStateIndex);
	static class APlayerState* GetPlayerStateFromUniqueNetId(const class UObject* WorldContextObject, const struct FUniqueNetIdRepl& UniqueID);
	static double GetRealTimeSeconds(const class UObject* WorldContextObject);
	static class ULevelStreaming* GetStreamingLevel(const class UObject* WorldContextObject, class FName PackageName);
	static EPhysicalSurface GetSurfaceType(const struct FHitResult& Hit);
	static double GetTimeSeconds(const class UObject* WorldContextObject);
	static double GetUnpausedTimeSeconds(const class UObject* WorldContextObject);
	static EMouseCaptureMode GetViewportMouseCaptureMode(const class UObject* WorldContextObject);
	static void GetViewProjectionMatrix(const struct FMinimalViewInfo& DesiredView, struct FMatrix* ViewMatrix, struct FMatrix* ProjectionMatrix, struct FMatrix* ViewProjectionMatrix);
	static double GetWorldDeltaSeconds(const class UObject* WorldContextObject);
	static struct FIntVector GetWorldOriginLocation(const class UObject* WorldContextObject);
	static int32 GrassOverlappingSphereCount(const class UObject* WorldContextObject, const class UStaticMesh* StaticMesh, const struct FVector& CenterPosition, float Radius);
	static bool HasLaunchOption(const class FString& OptionToCheck);
	static bool HasOption(const class FString& OPTIONS, const class FString& InKey);
	static bool IsAnyLocalPlayerCameraWithinRange(const class UObject* WorldContextObject, const struct FVector& Location, float MaximumRange);
	static bool IsGamePaused(const class UObject* WorldContextObject);
	static bool IsSplitscreenForceDisabled(const class UObject* WorldContextObject);
	static class USaveGame* LoadGameFromSlot(const class FString& SlotName, const int32 UserIndex);
	static void LoadStreamLevel(const class UObject* WorldContextObject, class FName LevelName, bool bMakeVisibleAfterLoad, bool bShouldBlockOnLoad, const struct FLatentActionInfo& LatentInfo);
	static void LoadStreamLevelBySoftObjectPtr(const class UObject* WorldContextObject, const TSoftObjectPtr<class UWorld> Level, bool bMakeVisibleAfterLoad, bool bShouldBlockOnLoad, const struct FLatentActionInfo& LatentInfo);
	static struct FHitResult MakeHitResult(bool bBlockingHit, bool bInitialOverlap, float Time, float Distance, const struct FVector& Location, const struct FVector& ImpactPoint, const struct FVector& Normal, const struct FVector& ImpactNormal, class UPhysicalMaterial* PhysMat, class AActor* HitActor, class UPrimitiveComponent* HitComponent, class FName HitBoneName, class FName BoneName, int32 HitItem, int32 ElementIndex, int32 FaceIndex, const struct FVector& TraceStart, const struct FVector& TraceEnd);
	static bool ObjectIsA(const class UObject* Object, TSubclassOf<class UObject> ObjectClass);
	static void OpenLevel(const class UObject* WorldContextObject, class FName LevelName, bool bAbsolute, const class FString& OPTIONS);
	static void OpenLevelBySoftObjectPtr(const class UObject* WorldContextObject, const TSoftObjectPtr<class UWorld> Level, bool bAbsolute, const class FString& OPTIONS);
	static class FString ParseOption(const class FString& OPTIONS, const class FString& Key);
	static void PlayDialogue2D(const class UObject* WorldContextObject, class UDialogueWave* Dialogue, const struct FDialogueContext& Context, float VolumeMultiplier, float PitchMultiplier, float startTime);
	static void PlayDialogueAtLocation(const class UObject* WorldContextObject, class UDialogueWave* Dialogue, const struct FDialogueContext& Context, const struct FVector& Location, const struct FRotator& Rotation, float VolumeMultiplier, float PitchMultiplier, float startTime, class USoundAttenuation* AttenuationSettings);
	static void PlaySound2D(const class UObject* WorldContextObject, class USoundBase* Sound, float VolumeMultiplier, float PitchMultiplier, float startTime, class USoundConcurrency* ConcurrencySettings, const class AActor* OwningActor, bool bIsUISound);
	static void PlaySoundAtLocation(const class UObject* WorldContextObject, class USoundBase* Sound, const struct FVector& Location, const struct FRotator& Rotation, float VolumeMultiplier, float PitchMultiplier, float startTime, class USoundAttenuation* AttenuationSettings, class USoundConcurrency* ConcurrencySettings, const class AActor* OwningActor, const class UInitialActiveSoundParams* InitialParams);
	static void PlayWorldCameraShake(const class UObject* WorldContextObject, TSubclassOf<class UCameraShakeBase> Shake, const struct FVector& Epicenter, float InnerRadius, float OuterRadius, float Falloff, bool bOrientShakeTowardsEpicenter);
	static void PopSoundMixModifier(const class UObject* WorldContextObject, class USoundMix* InSoundMixModifier);
	static void PrimeAllSoundsInSoundClass(class USoundClass* InSoundClass);
	static void PrimeSound(class USoundBase* InSound);
	static bool ProjectWorldToScreen(class APlayerController* Player, const struct FVector& WorldPosition, struct FVector2D* ScreenPosition, bool bPlayerViewportRelative);
	static void PushSoundMixModifier(const class UObject* WorldContextObject, class USoundMix* InSoundMixModifier);
	static struct FVector RebaseLocalOriginOntoZero(class UObject* WorldContextObject, const struct FVector& WorldLocation);
	static struct FVector RebaseZeroOriginOntoLocal(class UObject* WorldContextObject, const struct FVector& WorldLocation);
	static void RemovePlayer(class APlayerController* Player, bool bDestroyPawn);
	static bool SaveGameToSlot(class USaveGame* SaveGameObject, const class FString& SlotName, const int32 UserIndex);
	static bool SetActiveSpatialPluginByName(const class UObject* WorldContextObject, class FName InPluginName);
	static void SetBaseSoundMix(const class UObject* WorldContextObject, class USoundMix* InSoundMix);
	static void SetEnableWorldRendering(const class UObject* WorldContextObject, bool bEnable);
	static void SetForceDisableSplitscreen(const class UObject* WorldContextObject, bool bDisable);
	static bool SetGamePaused(const class UObject* WorldContextObject, bool bPaused);
	static void SetGlobalListenerFocusParameters(const class UObject* WorldContextObject, float FocusAzimuthScale, float NonFocusAzimuthScale, float FocusDistanceScale, float NonFocusDistanceScale, float FocusVolumeScale, float NonFocusVolumeScale, float FocusPriorityScale, float NonFocusPriorityScale);
	static void SetGlobalPitchModulation(const class UObject* WorldContextObject, float PitchModulation, float TimeSec);
	static void SetGlobalTimeDilation(const class UObject* WorldContextObject, float TimeDilation);
	static void SetMaxAudioChannelsScaled(const class UObject* WorldContextObject, float MaxChannelCountScale);
	static void SetPlayerControllerID(class APlayerController* Player, int32 ControllerId);
	static void SetPlayerPlatformUserId(class APlayerController* PlayerController, const struct FPlatformUserId& UserId);
	static void SetSoundClassDistanceScale(const class UObject* WorldContextObject, class USoundClass* SoundClass, float DistanceAttenuationScale, float TimeSec);
	static void SetSoundMixClassOverride(const class UObject* WorldContextObject, class USoundMix* InSoundMixModifier, class USoundClass* InSoundClass, float Volume, float Pitch, float FadeInTime, bool bApplyToChildren);
	static void SetSubtitlesEnabled(bool bEnabled);
	static void SetViewportMouseCaptureMode(const class UObject* WorldContextObject, const EMouseCaptureMode MouseCaptureMode);
	static void SetWorldOriginLocation(const class UObject* WorldContextObject, const struct FIntVector& NewLocation);
	static class UDecalComponent* SpawnDecalAtLocation(const class UObject* WorldContextObject, class UMaterialInterface* DecalMaterial, const struct FVector& DecalSize, const struct FVector& Location, const struct FRotator& Rotation, float LifeSpan);
	static class UDecalComponent* SpawnDecalAttached(class UMaterialInterface* DecalMaterial, const struct FVector& DecalSize, class USceneComponent* AttachToComponent, class FName AttachPointName, const struct FVector& Location, const struct FRotator& Rotation, EAttachLocation LocationType, float LifeSpan);
	static class UAudioComponent* SpawnDialogue2D(const class UObject* WorldContextObject, class UDialogueWave* Dialogue, const struct FDialogueContext& Context, float VolumeMultiplier, float PitchMultiplier, float startTime, bool bAutoDestroy);
	static class UAudioComponent* SpawnDialogueAtLocation(const class UObject* WorldContextObject, class UDialogueWave* Dialogue, const struct FDialogueContext& Context, const struct FVector& Location, const struct FRotator& Rotation, float VolumeMultiplier, float PitchMultiplier, float startTime, class USoundAttenuation* AttenuationSettings, bool bAutoDestroy);
	static class UAudioComponent* SpawnDialogueAttached(class UDialogueWave* Dialogue, const struct FDialogueContext& Context, class USceneComponent* AttachToComponent, class FName AttachPointName, const struct FVector& Location, const struct FRotator& Rotation, EAttachLocation LocationType, bool bStopWhenAttachedToDestroyed, float VolumeMultiplier, float PitchMultiplier, float startTime, class USoundAttenuation* AttenuationSettings, bool bAutoDestroy);
	static class UParticleSystemComponent* SpawnEmitterAtLocation(const class UObject* WorldContextObject, class UParticleSystem* EmitterTemplate, const struct FVector& Location, const struct FRotator& Rotation, const struct FVector& Scale, bool bAutoDestroy, EPSCPoolMethod PoolingMethod, bool bAutoActivateSystem);
	static class UParticleSystemComponent* SpawnEmitterAttached(class UParticleSystem* EmitterTemplate, class USceneComponent* AttachToComponent, class FName AttachPointName, const struct FVector& Location, const struct FRotator& Rotation, const struct FVector& Scale, EAttachLocation LocationType, bool bAutoDestroy, EPSCPoolMethod PoolingMethod, bool bAutoActivate);
	static class UForceFeedbackComponent* SpawnForceFeedbackAtLocation(const class UObject* WorldContextObject, class UForceFeedbackEffect* ForceFeedbackEffect, const struct FVector& Location, const struct FRotator& Rotation, bool bLooping, float IntensityMultiplier, float startTime, class UForceFeedbackAttenuation* AttenuationSettings, bool bAutoDestroy);
	static class UForceFeedbackComponent* SpawnForceFeedbackAttached(class UForceFeedbackEffect* ForceFeedbackEffect, class USceneComponent* AttachToComponent, class FName AttachPointName, const struct FVector& Location, const struct FRotator& Rotation, EAttachLocation LocationType, bool bStopWhenAttachedToDestroyed, bool bLooping, float IntensityMultiplier, float startTime, class UForceFeedbackAttenuation* AttenuationSettings, bool bAutoDestroy);
	static class UObject* SpawnObject(TSubclassOf<class UObject> ObjectClass, class UObject* Outer_0);
	static class UAudioComponent* SpawnSound2D(const class UObject* WorldContextObject, class USoundBase* Sound, float VolumeMultiplier, float PitchMultiplier, float startTime, class USoundConcurrency* ConcurrencySettings, bool bPersistAcrossLevelTransition, bool bAutoDestroy);
	static class UAudioComponent* SpawnSoundAtLocation(const class UObject* WorldContextObject, class USoundBase* Sound, const struct FVector& Location, const struct FRotator& Rotation, float VolumeMultiplier, float PitchMultiplier, float startTime, class USoundAttenuation* AttenuationSettings, class USoundConcurrency* ConcurrencySettings, bool bAutoDestroy);
	static class UAudioComponent* SpawnSoundAttached(class USoundBase* Sound, class USceneComponent* AttachToComponent, class FName AttachPointName, const struct FVector& Location, const struct FRotator& Rotation, EAttachLocation LocationType, bool bStopWhenAttachedToDestroyed, float VolumeMultiplier, float PitchMultiplier, float startTime, class USoundAttenuation* AttenuationSettings, class USoundConcurrency* ConcurrencySettings, bool bAutoDestroy);
	static bool SuggestProjectileVelocity_CustomArc(const class UObject* WorldContextObject, struct FVector* OutLaunchVelocity, const struct FVector& StartPos, const struct FVector& EndPos, float OverrideGravityZ, float ArcParam);
	static bool SuggestProjectileVelocity_MovingTarget(const class UObject* WorldContextObject, struct FVector* OutLaunchVelocity, const struct FVector& ProjectileStartLocation, class AActor* TargetActor, const struct FVector& TargetLocationOffset, double GravityZOverride, double TimeToTarget, EDrawDebugTrace DrawDebugType, float DrawDebugTime, const struct FLinearColor& DrawDebugColor);
	static void UnloadStreamLevel(const class UObject* WorldContextObject, class FName LevelName, const struct FLatentActionInfo& LatentInfo, bool bShouldBlockOnUnload);
	static void UnloadStreamLevelBySoftObjectPtr(const class UObject* WorldContextObject, const TSoftObjectPtr<class UWorld> Level, const struct FLatentActionInfo& LatentInfo, bool bShouldBlockOnUnload);
	static void UnRetainAllSoundsInSoundClass(class USoundClass* InSoundClass);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"GameplayStatics">();
	}
	static class UGameplayStatics* GetDefaultObj()
	{
		return GetDefaultObjImpl<UGameplayStatics>();
	}
};
static_assert(alignof(UGameplayStatics) == 0x000008, "Wrong alignment on UGameplayStatics");
static_assert(sizeof(UGameplayStatics) == 0x000028, "Wrong size on UGameplayStatics");

// Class Engine.GameSession
// 0x0018 (0x02B8 - 0x02A0)
class AGameSession final : public AInfo
{
public:
	int32                                         MaxSpectators;                                     // 0x02A0(0x0004)(ZeroConstructor, Config, GlobalConfig, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         MaxPlayers;                                        // 0x02A4(0x0004)(ZeroConstructor, Config, GlobalConfig, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         MaxPartySize;                                      // 0x02A8(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         MaxSplitscreensPerConnection;                      // 0x02AC(0x0001)(ZeroConstructor, Config, GlobalConfig, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bRequiresPushToTalk;                               // 0x02AD(0x0001)(ZeroConstructor, Config, GlobalConfig, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_2AE[0x2];                                      // 0x02AE(0x0002)(Fixing Size After Last Property [ Dumper-7 ])
	class FName                                   SessionName;                                       // 0x02B0(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"GameSession">();
	}
	static class AGameSession* GetDefaultObj()
	{
		return GetDefaultObjImpl<AGameSession>();
	}
};
static_assert(alignof(AGameSession) == 0x000008, "Wrong alignment on AGameSession");
static_assert(sizeof(AGameSession) == 0x0002B8, "Wrong size on AGameSession");
static_assert(offsetof(AGameSession, MaxSpectators) == 0x0002A0, "Member 'AGameSession::MaxSpectators' has a wrong offset!");
static_assert(offsetof(AGameSession, MaxPlayers) == 0x0002A4, "Member 'AGameSession::MaxPlayers' has a wrong offset!");
static_assert(offsetof(AGameSession, MaxPartySize) == 0x0002A8, "Member 'AGameSession::MaxPartySize' has a wrong offset!");
static_assert(offsetof(AGameSession, MaxSplitscreensPerConnection) == 0x0002AC, "Member 'AGameSession::MaxSplitscreensPerConnection' has a wrong offset!");
static_assert(offsetof(AGameSession, bRequiresPushToTalk) == 0x0002AD, "Member 'AGameSession::bRequiresPushToTalk' has a wrong offset!");
static_assert(offsetof(AGameSession, SessionName) == 0x0002B0, "Member 'AGameSession::SessionName' has a wrong offset!");

// Class Engine.GameStateBase
// 0x0058 (0x02F8 - 0x02A0)
class AGameStateBase : public AInfo
{
public:
	TSubclassOf<class AGameModeBase>              GameModeClass;                                     // 0x02A0(0x0008)(BlueprintVisible, BlueprintReadOnly, Net, ZeroConstructor, Transient, RepNotify, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AGameModeBase*                          AuthorityGameMode;                                 // 0x02A8(0x0008)(BlueprintVisible, BlueprintReadOnly, ZeroConstructor, Transient, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TSubclassOf<class ASpectatorPawn>             SpectatorClass;                                    // 0x02B0(0x0008)(BlueprintVisible, BlueprintReadOnly, Net, ZeroConstructor, Transient, RepNotify, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TArray<class APlayerState*>                   PlayerArray;                                       // 0x02B8(0x0010)(BlueprintVisible, BlueprintReadOnly, ZeroConstructor, Transient, UObjectWrapper, NativeAccessSpecifierPublic)
	bool                                          bReplicatedHasBegunPlay;                           // 0x02C8(0x0001)(Net, ZeroConstructor, Transient, IsPlainOldData, RepNotify, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_2C9[0x3];                                      // 0x02C9(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         ReplicatedWorldTimeSeconds;                        // 0x02CC(0x0004)(Net, ZeroConstructor, Transient, IsPlainOldData, RepNotify, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	double                                        ReplicatedWorldTimeSecondsDouble;                  // 0x02D0(0x0008)(Net, ZeroConstructor, Transient, IsPlainOldData, RepNotify, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	float                                         ServerWorldTimeSecondsDelta;                       // 0x02D8(0x0004)(ZeroConstructor, Transient, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	float                                         ServerWorldTimeSecondsUpdateFrequency;             // 0x02DC(0x0004)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_2E0[0x18];                                     // 0x02E0(0x0018)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void OnRep_GameModeClass();
	void OnRep_ReplicatedHasBegunPlay();
	void OnRep_ReplicatedWorldTimeSeconds();
	void OnRep_ReplicatedWorldTimeSecondsDouble();
	void OnRep_SpectatorClass();

	float GetPlayerRespawnDelay(class AController* Controller) const;
	float GetPlayerStartTime(class AController* Controller) const;
	double GetServerWorldTimeSeconds() const;
	bool HasBegunPlay() const;
	bool HasMatchEnded() const;
	bool HasMatchStarted() const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"GameStateBase">();
	}
	static class AGameStateBase* GetDefaultObj()
	{
		return GetDefaultObjImpl<AGameStateBase>();
	}
};
static_assert(alignof(AGameStateBase) == 0x000008, "Wrong alignment on AGameStateBase");
static_assert(sizeof(AGameStateBase) == 0x0002F8, "Wrong size on AGameStateBase");
static_assert(offsetof(AGameStateBase, GameModeClass) == 0x0002A0, "Member 'AGameStateBase::GameModeClass' has a wrong offset!");
static_assert(offsetof(AGameStateBase, AuthorityGameMode) == 0x0002A8, "Member 'AGameStateBase::AuthorityGameMode' has a wrong offset!");
static_assert(offsetof(AGameStateBase, SpectatorClass) == 0x0002B0, "Member 'AGameStateBase::SpectatorClass' has a wrong offset!");
static_assert(offsetof(AGameStateBase, PlayerArray) == 0x0002B8, "Member 'AGameStateBase::PlayerArray' has a wrong offset!");
static_assert(offsetof(AGameStateBase, bReplicatedHasBegunPlay) == 0x0002C8, "Member 'AGameStateBase::bReplicatedHasBegunPlay' has a wrong offset!");
static_assert(offsetof(AGameStateBase, ReplicatedWorldTimeSeconds) == 0x0002CC, "Member 'AGameStateBase::ReplicatedWorldTimeSeconds' has a wrong offset!");
static_assert(offsetof(AGameStateBase, ReplicatedWorldTimeSecondsDouble) == 0x0002D0, "Member 'AGameStateBase::ReplicatedWorldTimeSecondsDouble' has a wrong offset!");
static_assert(offsetof(AGameStateBase, ServerWorldTimeSecondsDelta) == 0x0002D8, "Member 'AGameStateBase::ServerWorldTimeSecondsDelta' has a wrong offset!");
static_assert(offsetof(AGameStateBase, ServerWorldTimeSecondsUpdateFrequency) == 0x0002DC, "Member 'AGameStateBase::ServerWorldTimeSecondsUpdateFrequency' has a wrong offset!");

// Class Engine.GameState
// 0x0020 (0x0318 - 0x02F8)
class AGameState final : public AGameStateBase
{
public:
	class FName                                   MatchState;                                        // 0x02F8(0x0008)(Edit, BlueprintVisible, BlueprintReadOnly, Net, ZeroConstructor, DisableEditOnTemplate, EditConst, IsPlainOldData, RepNotify, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	class FName                                   PreviousMatchState;                                // 0x0300(0x0008)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, DisableEditOnTemplate, EditConst, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	int32                                         ElapsedTime;                                       // 0x0308(0x0004)(BlueprintVisible, BlueprintReadOnly, Net, ZeroConstructor, IsPlainOldData, RepNotify, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_30C[0xC];                                      // 0x030C(0x000C)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void OnRep_ElapsedTime();
	void OnRep_MatchState();

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"GameState">();
	}
	static class AGameState* GetDefaultObj()
	{
		return GetDefaultObjImpl<AGameState>();
	}
};
static_assert(alignof(AGameState) == 0x000008, "Wrong alignment on AGameState");
static_assert(sizeof(AGameState) == 0x000318, "Wrong size on AGameState");
static_assert(offsetof(AGameState, MatchState) == 0x0002F8, "Member 'AGameState::MatchState' has a wrong offset!");
static_assert(offsetof(AGameState, PreviousMatchState) == 0x000300, "Member 'AGameState::PreviousMatchState' has a wrong offset!");
static_assert(offsetof(AGameState, ElapsedTime) == 0x000308, "Member 'AGameState::ElapsedTime' has a wrong offset!");

// Class Engine.ScriptViewportClient
// 0x0010 (0x0038 - 0x0028)
class UScriptViewportClient : public UObject
{
public:
	uint8                                         Pad_28[0x10];                                      // 0x0028(0x0010)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ScriptViewportClient">();
	}
	static class UScriptViewportClient* GetDefaultObj()
	{
		return GetDefaultObjImpl<UScriptViewportClient>();
	}
};
static_assert(alignof(UScriptViewportClient) == 0x000008, "Wrong alignment on UScriptViewportClient");
static_assert(sizeof(UScriptViewportClient) == 0x000038, "Wrong size on UScriptViewportClient");

// Class Engine.GameViewportClient
// 0x0378 (0x03B0 - 0x0038)
class UGameViewportClient : public UScriptViewportClient
{
public:
	uint8                                         Pad_38[0x8];                                       // 0x0038(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	class UConsole*                               ViewportConsole;                                   // 0x0040(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TArray<struct FDebugDisplayProperty>          DebugProperties;                                   // 0x0048(0x0010)(ZeroConstructor, NativeAccessSpecifierPublic)
	uint8                                         Pad_58[0x10];                                      // 0x0058(0x0010)(Fixing Size After Last Property [ Dumper-7 ])
	int32                                         MaxSplitscreenPlayers;                             // 0x0068(0x0004)(ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_6C[0xC];                                       // 0x006C(0x000C)(Fixing Size After Last Property [ Dumper-7 ])
	class UWorld*                                 World;                                             // 0x0078(0x0008)(ZeroConstructor, NoDestructor, Protected, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	class UGameInstance*                          GameInstance;                                      // 0x0080(0x0008)(ZeroConstructor, NoDestructor, Protected, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_88[0x328];                                     // 0x0088(0x0328)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void SetConsoleTarget(int32 PlayerIndex);
	void ShowTitleSafeArea();
	void SSSwapControllers();

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"GameViewportClient">();
	}
	static class UGameViewportClient* GetDefaultObj()
	{
		return GetDefaultObjImpl<UGameViewportClient>();
	}
};
static_assert(alignof(UGameViewportClient) == 0x000008, "Wrong alignment on UGameViewportClient");
static_assert(sizeof(UGameViewportClient) == 0x0003B0, "Wrong size on UGameViewportClient");
static_assert(offsetof(UGameViewportClient, ViewportConsole) == 0x000040, "Member 'UGameViewportClient::ViewportConsole' has a wrong offset!");
static_assert(offsetof(UGameViewportClient, DebugProperties) == 0x000048, "Member 'UGameViewportClient::DebugProperties' has a wrong offset!");
static_assert(offsetof(UGameViewportClient, MaxSplitscreenPlayers) == 0x000068, "Member 'UGameViewportClient::MaxSplitscreenPlayers' has a wrong offset!");
static_assert(offsetof(UGameViewportClient, World) == 0x000078, "Member 'UGameViewportClient::World' has a wrong offset!");
static_assert(offsetof(UGameViewportClient, GameInstance) == 0x000080, "Member 'UGameViewportClient::GameInstance' has a wrong offset!");

// Class Engine.HLODProxy
// 0x0060 (0x0088 - 0x0028)
class UHLODProxy final : public UObject
{
public:
	TArray<struct FHLODProxyMesh>                 ProxyMeshes;                                       // 0x0028(0x0010)(Edit, ZeroConstructor, EditConst, NativeAccessSpecifierPrivate)
	TMap<class UHLODProxyDesc*, struct FHLODProxyMesh> HLODActors;                                   // 0x0038(0x0050)(Edit, EditConst, NativeAccessSpecifierPrivate)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"HLODProxy">();
	}
	static class UHLODProxy* GetDefaultObj()
	{
		return GetDefaultObjImpl<UHLODProxy>();
	}
};
static_assert(alignof(UHLODProxy) == 0x000008, "Wrong alignment on UHLODProxy");
static_assert(sizeof(UHLODProxy) == 0x000088, "Wrong size on UHLODProxy");
static_assert(offsetof(UHLODProxy, ProxyMeshes) == 0x000028, "Member 'UHLODProxy::ProxyMeshes' has a wrong offset!");
static_assert(offsetof(UHLODProxy, HLODActors) == 0x000038, "Member 'UHLODProxy::HLODActors' has a wrong offset!");

// Class Engine.HLODProxyDesc
// 0x0000 (0x0028 - 0x0028)
class UHLODProxyDesc final : public UObject
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"HLODProxyDesc">();
	}
	static class UHLODProxyDesc* GetDefaultObj()
	{
		return GetDefaultObjImpl<UHLODProxyDesc>();
	}
};
static_assert(alignof(UHLODProxyDesc) == 0x000008, "Wrong alignment on UHLODProxyDesc");
static_assert(sizeof(UHLODProxyDesc) == 0x000028, "Wrong size on UHLODProxyDesc");

// Class Engine.ImportantToggleSettingInterface
// 0x0000 (0x0000 - 0x0000)
class IImportantToggleSettingInterface final
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ImportantToggleSettingInterface">();
	}
	static class IImportantToggleSettingInterface* GetDefaultObj()
	{
		return GetDefaultObjImpl<IImportantToggleSettingInterface>();
	}

	class UObject* AsUObject()
	{
		return reinterpret_cast<UObject*>(this);
	}
	const class UObject* AsUObject() const
	{
		return reinterpret_cast<const UObject*>(this);
	}
};
static_assert(alignof(IImportantToggleSettingInterface) == 0x000001, "Wrong alignment on IImportantToggleSettingInterface");
static_assert(sizeof(IImportantToggleSettingInterface) == 0x000001, "Wrong size on IImportantToggleSettingInterface");

// Class Engine.InheritableComponentHandler
// 0x0020 (0x0048 - 0x0028)
class UInheritableComponentHandler final : public UObject
{
public:
	TArray<struct FComponentOverrideRecord>       Records;                                           // 0x0028(0x0010)(ZeroConstructor, ContainsInstancedReference, NativeAccessSpecifierPrivate)
	TArray<class UActorComponent*>                UnnecessaryComponents;                             // 0x0038(0x0010)(ExportObject, ZeroConstructor, Transient, ContainsInstancedReference, UObjectWrapper, NativeAccessSpecifierPrivate)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"InheritableComponentHandler">();
	}
	static class UInheritableComponentHandler* GetDefaultObj()
	{
		return GetDefaultObjImpl<UInheritableComponentHandler>();
	}
};
static_assert(alignof(UInheritableComponentHandler) == 0x000008, "Wrong alignment on UInheritableComponentHandler");
static_assert(sizeof(UInheritableComponentHandler) == 0x000048, "Wrong size on UInheritableComponentHandler");
static_assert(offsetof(UInheritableComponentHandler, Records) == 0x000028, "Member 'UInheritableComponentHandler::Records' has a wrong offset!");
static_assert(offsetof(UInheritableComponentHandler, UnnecessaryComponents) == 0x000038, "Member 'UInheritableComponentHandler::UnnecessaryComponents' has a wrong offset!");

// Class Engine.InputActionDelegateBinding
// 0x0010 (0x0038 - 0x0028)
class UInputActionDelegateBinding final : public UInputDelegateBinding
{
public:
	TArray<struct FBlueprintInputActionDelegateBinding> InputActionDelegateBindings;                 // 0x0028(0x0010)(ZeroConstructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"InputActionDelegateBinding">();
	}
	static class UInputActionDelegateBinding* GetDefaultObj()
	{
		return GetDefaultObjImpl<UInputActionDelegateBinding>();
	}
};
static_assert(alignof(UInputActionDelegateBinding) == 0x000008, "Wrong alignment on UInputActionDelegateBinding");
static_assert(sizeof(UInputActionDelegateBinding) == 0x000038, "Wrong size on UInputActionDelegateBinding");
static_assert(offsetof(UInputActionDelegateBinding, InputActionDelegateBindings) == 0x000028, "Member 'UInputActionDelegateBinding::InputActionDelegateBindings' has a wrong offset!");

// Class Engine.InputAxisDelegateBinding
// 0x0010 (0x0038 - 0x0028)
class UInputAxisDelegateBinding final : public UInputDelegateBinding
{
public:
	TArray<struct FBlueprintInputAxisDelegateBinding> InputAxisDelegateBindings;                     // 0x0028(0x0010)(ZeroConstructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"InputAxisDelegateBinding">();
	}
	static class UInputAxisDelegateBinding* GetDefaultObj()
	{
		return GetDefaultObjImpl<UInputAxisDelegateBinding>();
	}
};
static_assert(alignof(UInputAxisDelegateBinding) == 0x000008, "Wrong alignment on UInputAxisDelegateBinding");
static_assert(sizeof(UInputAxisDelegateBinding) == 0x000038, "Wrong size on UInputAxisDelegateBinding");
static_assert(offsetof(UInputAxisDelegateBinding, InputAxisDelegateBindings) == 0x000028, "Member 'UInputAxisDelegateBinding::InputAxisDelegateBindings' has a wrong offset!");

// Class Engine.InputAxisKeyDelegateBinding
// 0x0010 (0x0038 - 0x0028)
class UInputAxisKeyDelegateBinding : public UInputDelegateBinding
{
public:
	TArray<struct FBlueprintInputAxisKeyDelegateBinding> InputAxisKeyDelegateBindings;               // 0x0028(0x0010)(ZeroConstructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"InputAxisKeyDelegateBinding">();
	}
	static class UInputAxisKeyDelegateBinding* GetDefaultObj()
	{
		return GetDefaultObjImpl<UInputAxisKeyDelegateBinding>();
	}
};
static_assert(alignof(UInputAxisKeyDelegateBinding) == 0x000008, "Wrong alignment on UInputAxisKeyDelegateBinding");
static_assert(sizeof(UInputAxisKeyDelegateBinding) == 0x000038, "Wrong size on UInputAxisKeyDelegateBinding");
static_assert(offsetof(UInputAxisKeyDelegateBinding, InputAxisKeyDelegateBindings) == 0x000028, "Member 'UInputAxisKeyDelegateBinding::InputAxisKeyDelegateBindings' has a wrong offset!");

// Class Engine.InputKeyDelegateBinding
// 0x0010 (0x0038 - 0x0028)
class UInputKeyDelegateBinding final : public UInputDelegateBinding
{
public:
	TArray<struct FBlueprintInputKeyDelegateBinding> InputKeyDelegateBindings;                       // 0x0028(0x0010)(ZeroConstructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"InputKeyDelegateBinding">();
	}
	static class UInputKeyDelegateBinding* GetDefaultObj()
	{
		return GetDefaultObjImpl<UInputKeyDelegateBinding>();
	}
};
static_assert(alignof(UInputKeyDelegateBinding) == 0x000008, "Wrong alignment on UInputKeyDelegateBinding");
static_assert(sizeof(UInputKeyDelegateBinding) == 0x000038, "Wrong size on UInputKeyDelegateBinding");
static_assert(offsetof(UInputKeyDelegateBinding, InputKeyDelegateBindings) == 0x000028, "Member 'UInputKeyDelegateBinding::InputKeyDelegateBindings' has a wrong offset!");

// Class Engine.InputTouchDelegateBinding
// 0x0010 (0x0038 - 0x0028)
class UInputTouchDelegateBinding final : public UInputDelegateBinding
{
public:
	TArray<struct FBlueprintInputTouchDelegateBinding> InputTouchDelegateBindings;                   // 0x0028(0x0010)(ZeroConstructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"InputTouchDelegateBinding">();
	}
	static class UInputTouchDelegateBinding* GetDefaultObj()
	{
		return GetDefaultObjImpl<UInputTouchDelegateBinding>();
	}
};
static_assert(alignof(UInputTouchDelegateBinding) == 0x000008, "Wrong alignment on UInputTouchDelegateBinding");
static_assert(sizeof(UInputTouchDelegateBinding) == 0x000038, "Wrong size on UInputTouchDelegateBinding");
static_assert(offsetof(UInputTouchDelegateBinding, InputTouchDelegateBindings) == 0x000028, "Member 'UInputTouchDelegateBinding::InputTouchDelegateBindings' has a wrong offset!");

// Class Engine.InputVectorAxisDelegateBinding
// 0x0000 (0x0038 - 0x0038)
class UInputVectorAxisDelegateBinding final : public UInputAxisKeyDelegateBinding
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"InputVectorAxisDelegateBinding">();
	}
	static class UInputVectorAxisDelegateBinding* GetDefaultObj()
	{
		return GetDefaultObjImpl<UInputVectorAxisDelegateBinding>();
	}
};
static_assert(alignof(UInputVectorAxisDelegateBinding) == 0x000008, "Wrong alignment on UInputVectorAxisDelegateBinding");
static_assert(sizeof(UInputVectorAxisDelegateBinding) == 0x000038, "Wrong size on UInputVectorAxisDelegateBinding");

// Class Engine.InstancedPlacementPartitionActor
// 0x0000 (0x02B0 - 0x02B0)
class AInstancedPlacementPartitionActor final : public AISMPartitionActor
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"InstancedPlacementPartitionActor">();
	}
	static class AInstancedPlacementPartitionActor* GetDefaultObj()
	{
		return GetDefaultObjImpl<AInstancedPlacementPartitionActor>();
	}
};
static_assert(alignof(AInstancedPlacementPartitionActor) == 0x000008, "Wrong alignment on AInstancedPlacementPartitionActor");
static_assert(sizeof(AInstancedPlacementPartitionActor) == 0x0002B0, "Wrong size on AInstancedPlacementPartitionActor");

// Class Engine.StringTable
// 0x0018 (0x0040 - 0x0028)
class UStringTable final : public UObject
{
public:
	uint8                                         Pad_28[0x18];                                      // 0x0028(0x0018)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"StringTable">();
	}
	static class UStringTable* GetDefaultObj()
	{
		return GetDefaultObjImpl<UStringTable>();
	}
};
static_assert(alignof(UStringTable) == 0x000008, "Wrong alignment on UStringTable");
static_assert(sizeof(UStringTable) == 0x000040, "Wrong size on UStringTable");

// Class Engine.InterpCurveEdSetup
// 0x0018 (0x0040 - 0x0028)
class UInterpCurveEdSetup final : public UObject
{
public:
	TArray<struct FCurveEdTab>                    Tabs;                                              // 0x0028(0x0010)(ZeroConstructor, NativeAccessSpecifierPublic)
	int32                                         ActiveTab;                                         // 0x0038(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_3C[0x4];                                       // 0x003C(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"InterpCurveEdSetup">();
	}
	static class UInterpCurveEdSetup* GetDefaultObj()
	{
		return GetDefaultObjImpl<UInterpCurveEdSetup>();
	}
};
static_assert(alignof(UInterpCurveEdSetup) == 0x000008, "Wrong alignment on UInterpCurveEdSetup");
static_assert(sizeof(UInterpCurveEdSetup) == 0x000040, "Wrong size on UInterpCurveEdSetup");
static_assert(offsetof(UInterpCurveEdSetup, Tabs) == 0x000028, "Member 'UInterpCurveEdSetup::Tabs' has a wrong offset!");
static_assert(offsetof(UInterpCurveEdSetup, ActiveTab) == 0x000038, "Member 'UInterpCurveEdSetup::ActiveTab' has a wrong offset!");

// Class Engine.KillZVolume
// 0x0000 (0x02E8 - 0x02E8)
class AKillZVolume final : public APhysicsVolume
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"KillZVolume">();
	}
	static class AKillZVolume* GetDefaultObj()
	{
		return GetDefaultObjImpl<AKillZVolume>();
	}
};
static_assert(alignof(AKillZVolume) == 0x000008, "Wrong alignment on AKillZVolume");
static_assert(sizeof(AKillZVolume) == 0x0002E8, "Wrong size on AKillZVolume");

// Class Engine.KismetGuidLibrary
// 0x0000 (0x0028 - 0x0028)
class UKismetGuidLibrary final : public UBlueprintFunctionLibrary
{
public:
	static class FString Conv_GuidToString(const struct FGuid& InGuid);
	static bool EqualEqual_GuidGuid(const struct FGuid& A, const struct FGuid& B);
	static void Invalidate_Guid(struct FGuid& InGuid);
	static bool IsValid_Guid(const struct FGuid& InGuid);
	static struct FGuid NewGuid();
	static bool NotEqual_GuidGuid(const struct FGuid& A, const struct FGuid& B);
	static void Parse_StringToGuid(const class FString& GuidString, struct FGuid* OutGuid, bool* Success);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"KismetGuidLibrary">();
	}
	static class UKismetGuidLibrary* GetDefaultObj()
	{
		return GetDefaultObjImpl<UKismetGuidLibrary>();
	}
};
static_assert(alignof(UKismetGuidLibrary) == 0x000008, "Wrong alignment on UKismetGuidLibrary");
static_assert(sizeof(UKismetGuidLibrary) == 0x000028, "Wrong size on UKismetGuidLibrary");

// Class Engine.KismetInternationalizationLibrary
// 0x0000 (0x0028 - 0x0028)
class UKismetInternationalizationLibrary final : public UBlueprintFunctionLibrary
{
public:
	static void ClearCurrentAssetGroupCulture(const class FName AssetGroup, const bool SaveToConfig);
	static class FString GetCultureDisplayName(const class FString& Culture, const bool Localized);
	static class FString GetCurrentAssetGroupCulture(const class FName AssetGroup);
	static class FString GetCurrentCulture();
	static class FString GetCurrentLanguage();
	static class FString GetCurrentLocale();
	static TArray<class FString> GetLocalizedCultures(const bool IncludeGame, const bool IncludeEngine, const bool IncludeEditor, const bool IncludeAdditional);
	static class FString GetNativeCulture(const ELocalizedTextSourceCategory TextCategory);
	static class FString GetSuitableCulture(const TArray<class FString>& AvailableCultures, const class FString& CultureToMatch, const class FString& FallbackCulture);
	static bool SetCurrentAssetGroupCulture(const class FName AssetGroup, const class FString& Culture, const bool SaveToConfig);
	static bool SetCurrentCulture(const class FString& Culture, const bool SaveToConfig);
	static bool SetCurrentLanguage(const class FString& Culture, const bool SaveToConfig);
	static bool SetCurrentLanguageAndLocale(const class FString& Culture, const bool SaveToConfig);
	static bool SetCurrentLocale(const class FString& Culture, const bool SaveToConfig);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"KismetInternationalizationLibrary">();
	}
	static class UKismetInternationalizationLibrary* GetDefaultObj()
	{
		return GetDefaultObjImpl<UKismetInternationalizationLibrary>();
	}
};
static_assert(alignof(UKismetInternationalizationLibrary) == 0x000008, "Wrong alignment on UKismetInternationalizationLibrary");
static_assert(sizeof(UKismetInternationalizationLibrary) == 0x000028, "Wrong size on UKismetInternationalizationLibrary");

// Class Engine.KismetMaterialLibrary
// 0x0000 (0x0028 - 0x0028)
class UKismetMaterialLibrary final : public UBlueprintFunctionLibrary
{
public:
	static class UMaterialInstanceDynamic* CreateDynamicMaterialInstance(class UObject* WorldContextObject, class UMaterialInterface* Parent, class FName OptionalName, EMIDCreationFlags CreationFlags);
	static float GetScalarParameterValue(class UObject* WorldContextObject, class UMaterialParameterCollection* Collection, class FName ParameterName);
	static struct FLinearColor GetVectorParameterValue(class UObject* WorldContextObject, class UMaterialParameterCollection* Collection, class FName ParameterName);
	static void SetScalarParameterValue(class UObject* WorldContextObject, class UMaterialParameterCollection* Collection, class FName ParameterName, float ParameterValue);
	static void SetVectorParameterValue(class UObject* WorldContextObject, class UMaterialParameterCollection* Collection, class FName ParameterName, const struct FLinearColor& ParameterValue);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"KismetMaterialLibrary">();
	}
	static class UKismetMaterialLibrary* GetDefaultObj()
	{
		return GetDefaultObjImpl<UKismetMaterialLibrary>();
	}
};
static_assert(alignof(UKismetMaterialLibrary) == 0x000008, "Wrong alignment on UKismetMaterialLibrary");
static_assert(sizeof(UKismetMaterialLibrary) == 0x000028, "Wrong size on UKismetMaterialLibrary");

// Class Engine.KismetMathLibrary
// 0x0000 (0x0028 - 0x0028)
class UKismetMathLibrary final : public UBlueprintFunctionLibrary
{
public:
	static double Abs(double A);
	static int32 Abs_Int(int32 A);
	static int64 Abs_Int64(int64 A);
	static double Acos(double A);
	static uint8 Add_ByteByte(uint8 A, uint8 B);
	static struct FDateTime Add_DateTimeDateTime(const struct FDateTime& A, const struct FDateTime& B);
	static struct FDateTime Add_DateTimeTimespan(const struct FDateTime& A, const struct FTimespan& B);
	static double Add_DoubleDouble(double A, double B);
	static int64 Add_Int64Int64(int64 A, int64 B);
	static int32 Add_IntInt(int32 A, int32 B);
	static struct FIntPoint Add_IntPointInt(const struct FIntPoint& A, int32 B);
	static struct FIntPoint Add_IntPointIntPoint(const struct FIntPoint& A, const struct FIntPoint& B);
	static struct FLinearColor Add_LinearColorLinearColor(const struct FLinearColor& A, const struct FLinearColor& B);
	static struct FMatrix Add_MatrixMatrix(const struct FMatrix& A, const struct FMatrix& B);
	static struct FQuat Add_QuatQuat(const struct FQuat& A, const struct FQuat& B);
	static struct FTimespan Add_TimespanTimespan(const struct FTimespan& A, const struct FTimespan& B);
	static struct FVector2D Add_Vector2DFloat(const struct FVector2D& A, double B);
	static struct FVector2D Add_Vector2DVector2D(const struct FVector2D& A, const struct FVector2D& B);
	static struct FVector4 Add_Vector4Vector4(const struct FVector4& A, const struct FVector4& B);
	static struct FVector Add_VectorFloat(const struct FVector& A, double B);
	static struct FVector Add_VectorInt(const struct FVector& A, int32 B);
	static struct FVector Add_VectorVector(const struct FVector& A, const struct FVector& B);
	static int64 And_Int64Int64(int64 A, int64 B);
	static int32 And_IntInt(int32 A, int32 B);
	static double Asin(double A);
	static double Atan(double A);
	static double Atan2(double Y, double X);
	static void AverageOfIntArray(const TArray<int32>& IntArray, float* AverageValue);
	static uint8 BMax(uint8 A, uint8 B);
	static uint8 BMin(uint8 A, uint8 B);
	static bool BooleanAND(bool A, bool B);
	static bool BooleanNAND(bool A, bool B);
	static bool BooleanNOR(bool A, bool B);
	static bool BooleanOR(bool A, bool B);
	static bool BooleanXOR(bool A, bool B);
	static void BreakBoxSphereBounds(const struct FBoxSphereBounds& InBoxSphereBounds, struct FVector* Origin, struct FVector* BoxExtent, float* SphereRadius);
	static void BreakColor(const struct FLinearColor& InColor, float* R, float* G, float* B, float* A);
	static void BreakDateTime(const struct FDateTime& InDateTime, int32* Year, int32* Month, int32* Day, int32* Hour, int32* Minute, int32* Second, int32* Millisecond);
	static void BreakFrameRate(const struct FFrameRate& InFrameRate, int32* Numerator, int32* Denominator);
	static void BreakQualifiedFrameTime(const struct FQualifiedFrameTime& InFrameTime, struct FFrameNumber* frame, struct FFrameRate* FrameRate, float* SubFrame);
	static void BreakQuat(const struct FQuat& InQuat, float* X, float* Y, float* Z, float* W);
	static void BreakRandomStream(const struct FRandomStream& InRandomStream, int32* InitialSeed);
	static void BreakRotator(const struct FRotator& InRot, float* ROLL, float* Pitch, float* Yaw);
	static void BreakRotIntoAxes(const struct FRotator& InRot, struct FVector* X, struct FVector* Y, struct FVector* Z);
	static void BreakTimespan(const struct FTimespan& InTimespan, int32* Days, int32* Hours, int32* Minutes, int32* Seconds, int32* Milliseconds);
	static void BreakTimespan2(const struct FTimespan& InTimespan, int32* Days, int32* Hours, int32* Minutes, int32* Seconds, int32* FractionNano);
	static void BreakTransform(const struct FTransform& InTransform, struct FVector* Location, struct FRotator* Rotation, struct FVector* Scale);
	static void BreakVector(const struct FVector& InVec, double* X, double* Y, double* Z);
	static void BreakVector2D(const struct FVector2D& InVec, double* X, double* Y);
	static void BreakVector4(const struct FVector4& InVec, double* X, double* Y, double* Z, double* W);
	static void BreakVector_NetQuantize(const struct FVector_NetQuantize& InVec, double* X, double* Y, double* Z);
	static void BreakVector_NetQuantize10(const struct FVector_NetQuantize10& InVec, double* X, double* Y, double* Z);
	static void BreakVector_NetQuantize100(const struct FVector_NetQuantize100& InVec, double* X, double* Y, double* Z);
	static void BreakVector_NetQuantizeNormal(const struct FVector_NetQuantizeNormal& InVec, double* X, double* Y, double* Z);
	static struct FLinearColor CInterpTo(const struct FLinearColor& Current, const struct FLinearColor& Target, float DeltaTime, float InterpSpeed);
	static int32 Clamp(int32 Value, int32 Min_0, int32 Max_0);
	static double ClampAngle(double AngleDegrees, double MinAngleDegrees, double MaxAngleDegrees);
	static struct FVector2D ClampAxes2D(const struct FVector2D& A, double MinAxisVal, double MaxAxisVal);
	static float ClampAxis(float Angle);
	static int64 ClampInt64(int64 Value, int64 Min_0, int64 Max_0);
	static struct FVector ClampVectorSize(const struct FVector& A, double Min_0, double Max_0);
	static bool ClassIsChildOf(TSubclassOf<class UObject> TestClass, TSubclassOf<class UObject> ParentClass);
	static struct FRotator ComposeRotators(const struct FRotator& A, const struct FRotator& B);
	static struct FTransform ComposeTransforms(const struct FTransform& A, const struct FTransform& B);
	static uint8 Conv_BoolToByte(bool InBool);
	static double Conv_BoolToDouble(bool InBool);
	static int32 Conv_BoolToInt(bool InBool);
	static double Conv_ByteToDouble(uint8 InByte);
	static int32 Conv_ByteToInt(uint8 InByte);
	static int64 Conv_ByteToInt64(uint8 InByte);
	static struct FLinearColor Conv_ColorToLinearColor(const struct FColor& InColor);
	static float Conv_DoubleToFloat(double InDouble);
	static int64 Conv_DoubleToInt64(double InDouble);
	static struct FLinearColor Conv_DoubleToLinearColor(double InDouble);
	static struct FVector Conv_DoubleToVector(double InDouble);
	static struct FVector2D Conv_DoubleToVector2D(double InDouble);
	static double Conv_FloatToDouble(float InFloat);
	static uint8 Conv_Int64ToByte(int64 inInt);
	static double Conv_Int64ToDouble(int64 inInt);
	static int32 Conv_Int64ToInt(int64 inInt);
	static struct FVector2D Conv_IntPointToVector2D(const struct FIntPoint& InIntPoint);
	static bool Conv_IntToBool(int32 inInt);
	static uint8 Conv_IntToByte(int32 inInt);
	static double Conv_IntToDouble(int32 inInt);
	static int64 Conv_IntToInt64(int32 inInt);
	static struct FIntVector Conv_IntToIntVector(int32 inInt);
	static struct FVector Conv_IntToVector(int32 inInt);
	static struct FVector Conv_IntVectorToVector(const struct FIntVector& InIntVector);
	static struct FColor Conv_LinearColorToColor(const struct FLinearColor& InLinearColor, bool InUseSRGB);
	static struct FVector Conv_LinearColorToVector(const struct FLinearColor& InLinearColor);
	static struct FRotator Conv_MatrixToRotator(const struct FMatrix& InMatrix);
	static struct FTransform Conv_MatrixToTransform(const struct FMatrix& InMatrix);
	static struct FQuat Conv_RotatorToQuaternion(const struct FRotator& InRot);
	static struct FTransform Conv_RotatorToTransform(const struct FRotator& InRotator);
	static struct FVector Conv_RotatorToVector(const struct FRotator& InRot);
	static struct FMatrix Conv_TransformToMatrix(const struct FTransform& Transform);
	static struct FIntPoint Conv_Vector2DToIntPoint(const struct FVector2D& InVector2D);
	static struct FVector Conv_Vector2DToVector(const struct FVector2D& InVector2D, float Z);
	static struct FQuat Conv_Vector4ToQuaternion(const struct FVector4& InVec);
	static struct FRotator Conv_Vector4ToRotator(const struct FVector4& InVec);
	static struct FVector Conv_Vector4ToVector(const struct FVector4& InVector4);
	static struct FLinearColor Conv_VectorToLinearColor(const struct FVector& InVec);
	static struct FQuat Conv_VectorToQuaternion(const struct FVector& InVec);
	static struct FRotator Conv_VectorToRotator(const struct FVector& InVec);
	static struct FTransform Conv_VectorToTransform(const struct FVector& InLocation);
	static struct FVector2D Conv_VectorToVector2D(const struct FVector& InVector);
	static double Cos(double A);
	static struct FVector CreateVectorFromYawPitch(float Yaw, float Pitch, float Length);
	static struct FVector Cross_VectorVector(const struct FVector& A, const struct FVector& B);
	static double CrossProduct2D(const struct FVector2D& A, const struct FVector2D& B);
	static bool DateTimeFromIsoString(const class FString& IsoString, struct FDateTime* Result);
	static bool DateTimeFromString(const class FString& DateTimeString, struct FDateTime* Result);
	static struct FDateTime DateTimeMaxValue();
	static struct FDateTime DateTimeMinValue();
	static int32 DaysInMonth(int32 Year, int32 Month);
	static int32 DaysInYear(int32 Year);
	static double DegAcos(double A);
	static double DegAsin(double A);
	static double DegAtan(double A);
	static double DegAtan2(double Y, double X);
	static double DegCos(double A);
	static double DegreesToRadians(double A);
	static double DegSin(double A);
	static double DegTan(double A);
	static double Distance2D(const struct FVector2D& v1, const struct FVector2D& v2);
	static double DistanceSquared2D(const struct FVector2D& v1, const struct FVector2D& v2);
	static uint8 Divide_ByteByte(uint8 A, uint8 B);
	static double Divide_DoubleDouble(double A, double B);
	static int64 Divide_Int64Int64(int64 A, int64 B);
	static int32 Divide_IntInt(int32 A, int32 B);
	static struct FIntPoint Divide_IntPointInt(const struct FIntPoint& A, int32 B);
	static struct FIntPoint Divide_IntPointIntPoint(const struct FIntPoint& A, const struct FIntPoint& B);
	static struct FLinearColor Divide_LinearColorLinearColor(const struct FLinearColor& A, const struct FLinearColor& B);
	static struct FTimespan Divide_TimespanFloat(const struct FTimespan& A, float Scalar);
	static struct FVector2D Divide_Vector2DFloat(const struct FVector2D& A, double B);
	static struct FVector2D Divide_Vector2DVector2D(const struct FVector2D& A, const struct FVector2D& B);
	static struct FVector4 Divide_Vector4Vector4(const struct FVector4& A, const struct FVector4& B);
	static struct FVector Divide_VectorFloat(const struct FVector& A, double B);
	static struct FVector Divide_VectorInt(const struct FVector& A, int32 B);
	static struct FVector Divide_VectorVector(const struct FVector& A, const struct FVector& B);
	static double Dot_VectorVector(const struct FVector& A, const struct FVector& B);
	static double DotProduct2D(const struct FVector2D& A, const struct FVector2D& B);
	static float DynamicWeightedMovingAverage_Float(float CurrentSample, float PreviousSample, float MaxDistance, float MinWeight, float MaxWeight);
	static struct FRotator DynamicWeightedMovingAverage_FRotator(const struct FRotator& CurrentSample, const struct FRotator& PreviousSample, float MaxDistance, float MinWeight, float MaxWeight);
	static struct FVector DynamicWeightedMovingAverage_FVector(const struct FVector& CurrentSample, const struct FVector& PreviousSample, float MaxDistance, float MinWeight, float MaxWeight);
	static double Ease(double A, double B, double Alpha, EEasingFunc EasingFunc, double BlendExp, int32 Steps);
	static bool Equal_IntPointIntPoint(const struct FIntPoint& A, const struct FIntPoint& B);
	static bool EqualEqual_BoolBool(bool A, bool B);
	static bool EqualEqual_ByteByte(uint8 A, uint8 B);
	static bool EqualEqual_ClassClass(class UClass* A, class UClass* B);
	static bool EqualEqual_DateTimeDateTime(const struct FDateTime& A, const struct FDateTime& B);
	static bool EqualEqual_DoubleDouble(double A, double B);
	static bool EqualEqual_Int64Int64(int64 A, int64 B);
	static bool EqualEqual_IntInt(int32 A, int32 B);
	static bool EqualEqual_LinearColorLinearColor(const struct FLinearColor& A, const struct FLinearColor& B);
	static bool EqualEqual_MatrixMatrix(const struct FMatrix& A, const struct FMatrix& B, float Tolerance);
	static bool EqualEqual_NameName(class FName A, class FName B);
	static bool EqualEqual_ObjectObject(class UObject* A, class UObject* B);
	static bool EqualEqual_QuatQuat(const struct FQuat& A, const struct FQuat& B, float Tolerance);
	static bool EqualEqual_RotatorRotator(const struct FRotator& A, const struct FRotator& B, float ErrorTolerance);
	static bool EqualEqual_TimespanTimespan(const struct FTimespan& A, const struct FTimespan& B);
	static bool EqualEqual_TransformTransform(const struct FTransform& A, const struct FTransform& B);
	static bool EqualEqual_Vector2DVector2D(const struct FVector2D& A, const struct FVector2D& B, float ErrorTolerance);
	static bool EqualEqual_Vector4Vector4(const struct FVector4& A, const struct FVector4& B, float ErrorTolerance);
	static bool EqualEqual_VectorVector(const struct FVector& A, const struct FVector& B, float ErrorTolerance);
	static bool EqualExactly_Vector2DVector2D(const struct FVector2D& A, const struct FVector2D& B);
	static bool EqualExactly_Vector4Vector4(const struct FVector4& A, const struct FVector4& B);
	static bool EqualExactly_VectorVector(const struct FVector& A, const struct FVector& B);
	static double Exp(double A);
	static int32 FCeil(double A);
	static int64 FCeil64(double A);
	static double FClamp(double Value, double Min_0, double Max_0);
	static int32 FFloor(double A);
	static int64 FFloor64(double A);
	static struct FVector FindClosestPointOnLine(const struct FVector& Point, const struct FVector& LineOrigin, const struct FVector& LineDirection);
	static struct FVector FindClosestPointOnSegment(const struct FVector& Point, const struct FVector& SegmentStart, const struct FVector& SegmentEnd);
	static struct FRotator FindLookAtRotation(const struct FVector& START, const struct FVector& Target);
	static void FindNearestPointsOnLineSegments(const struct FVector& Segment1Start, const struct FVector& Segment1End, const struct FVector& Segment2Start, const struct FVector& Segment2End, struct FVector* Segment1Point, struct FVector* Segment2Point);
	static struct FRotator FindRelativeLookAtRotation(const struct FTransform& StartTransform, const struct FVector& TargetLocation);
	static double FInterpEaseInOut(double A, double B, double Alpha, double Exponent);
	static double FInterpTo(double Current, double Target, double DeltaTime, double InterpSpeed);
	static double FInterpTo_Constant(double Current, double Target, double DeltaTime, double InterpSpeed);
	static float FixedTurn(float InCurrent, float InDesired, float InDeltaRate);
	static float FloatSpringInterp(float Current, float Target, struct FFloatSpringState& SpringState, float Stiffness, float CriticalDampingFactor, float DeltaTime, float Mass, float TargetVelocityAmount, bool bClamp, float MinValue, float MaxValue, bool bInitializeFromTarget);
	static double FMax(double A, double B);
	static double FMin(double A, double B);
	static int32 FMod(double Dividend, double Divisor, double* Remainder);
	static int64 FMod64(double Dividend, double Divisor, double* Remainder);
	static double Fraction(double A);
	static struct FTimespan FromDays(float Days);
	static struct FTimespan FromHours(float Hours);
	static struct FTimespan FromMilliseconds(float Milliseconds);
	static struct FTimespan FromMinutes(float Minutes);
	static struct FTimespan FromSeconds(float Seconds);
	static struct FDateTime FromUnixTimestamp(const int64 UnixTime);
	static int32 FTrunc(double A);
	static int64 FTrunc64(double A);
	static struct FIntVector FTruncVector(const struct FVector& InVector);
	static double FWrap(double Value, double Min_0, double Max_0);
	static struct FVector2D GetAbs2D(const struct FVector2D& A);
	static double GetAbsMax2D(const struct FVector2D& A);
	static void GetAxes(const struct FRotator& A, struct FVector* X, struct FVector* Y, struct FVector* Z);
	static void GetAzimuthAndElevation(const struct FVector& InDirection, const struct FTransform& ReferenceFrame, float* Azimuth, float* Elevation);
	static struct FDateTime GetDate(const struct FDateTime& A);
	static int32 GetDay(const struct FDateTime& A);
	static int32 GetDayOfYear(const struct FDateTime& A);
	static int32 GetDays(const struct FTimespan& A);
	static struct FVector GetDirectionUnitVector(const struct FVector& from, const struct FVector& to);
	static struct FTimespan GetDuration(const struct FTimespan& A);
	static struct FVector GetForwardVector(const struct FRotator& InRot);
	static int32 GetHour(const struct FDateTime& A);
	static int32 GetHour12(const struct FDateTime& A);
	static int32 GetHours(const struct FTimespan& A);
	static double GetMax2D(const struct FVector2D& A);
	static double GetMaxElement(const struct FVector& A);
	static int32 GetMillisecond(const struct FDateTime& A);
	static int32 GetMilliseconds(const struct FTimespan& A);
	static double GetMin2D(const struct FVector2D& A);
	static double GetMinElement(const struct FVector& A);
	static int32 GetMinute(const struct FDateTime& A);
	static int32 GetMinutes(const struct FTimespan& A);
	static int32 GetMonth(const struct FDateTime& A);
	static double GetPI();
	static float GetPointDistanceToLine(const struct FVector& Point, const struct FVector& LineOrigin, const struct FVector& LineDirection);
	static float GetPointDistanceToSegment(const struct FVector& Point, const struct FVector& SegmentStart, const struct FVector& SegmentEnd);
	static struct FVector GetReflectionVector(const struct FVector& Direction, const struct FVector& SurfaceNormal);
	static struct FVector GetRightVector(const struct FRotator& InRot);
	static struct FVector2D GetRotated2D(const struct FVector2D& A, float AngleDeg);
	static int32 GetSecond(const struct FDateTime& A);
	static int32 GetSeconds(const struct FTimespan& A);
	static void GetSlopeDegreeAngles(const struct FVector& MyRightYAxis, const struct FVector& FloorNormal, const struct FVector& UpVector, float* OutSlopePitchDegreeAngle, float* OutSlopeRollDegreeAngle);
	static double GetTAU();
	static struct FTimespan GetTimeOfDay(const struct FDateTime& A);
	static float GetTotalDays(const struct FTimespan& A);
	static float GetTotalHours(const struct FTimespan& A);
	static float GetTotalMilliseconds(const struct FTimespan& A);
	static float GetTotalMinutes(const struct FTimespan& A);
	static float GetTotalSeconds(const struct FTimespan& A);
	static struct FVector GetUpVector(const struct FRotator& InRot);
	static struct FVector GetVectorArrayAverage(const TArray<struct FVector>& Vectors);
	static void GetYawPitchFromVector(const struct FVector& InVec, float* Yaw, float* Pitch);
	static int32 GetYear(const struct FDateTime& A);
	static bool Greater_ByteByte(uint8 A, uint8 B);
	static bool Greater_DateTimeDateTime(const struct FDateTime& A, const struct FDateTime& B);
	static bool Greater_DoubleDouble(double A, double B);
	static bool Greater_Int64Int64(int64 A, int64 B);
	static bool Greater_IntInt(int32 A, int32 B);
	static bool Greater_TimespanTimespan(const struct FTimespan& A, const struct FTimespan& B);
	static bool GreaterEqual_ByteByte(uint8 A, uint8 B);
	static bool GreaterEqual_DateTimeDateTime(const struct FDateTime& A, const struct FDateTime& B);
	static bool GreaterEqual_DoubleDouble(double A, double B);
	static bool GreaterEqual_Int64Int64(int64 A, int64 B);
	static bool GreaterEqual_IntInt(int32 A, int32 B);
	static bool GreaterEqual_TimespanTimespan(const struct FTimespan& A, const struct FTimespan& B);
	static struct FVector GreaterGreater_VectorRotator(const struct FVector& A, const struct FRotator& B);
	static double GridSnap_Float(double Location, double GridSize);
	static struct FLinearColor HSVToRGB(float H, float S, float V, float A);
	static void HSVToRGB_Vector(const struct FLinearColor& HSV, struct FLinearColor* RGB);
	static struct FLinearColor HSVToRGBLinear(const struct FLinearColor& HSV);
	static double Hypotenuse(double Width, double Height);
	static bool InRange_FloatFloat(double Value, double Min_0, double Max_0, bool InclusiveMin, bool InclusiveMax);
	static bool InRange_Int64Int64(int64 Value, int64 Min_0, int64 Max_0, bool InclusiveMin, bool InclusiveMax);
	static bool InRange_IntInt(int32 Value, int32 Min_0, int32 Max_0, bool InclusiveMin, bool InclusiveMax);
	static struct FIntPoint IntPoint_Down();
	static struct FIntPoint IntPoint_Left();
	static struct FIntPoint IntPoint_One();
	static struct FIntPoint IntPoint_Right();
	static struct FIntPoint IntPoint_Up();
	static struct FIntPoint IntPoint_Zero();
	static struct FVector InverseTransformDirection(const struct FTransform& T, const struct FVector& Direction);
	static struct FVector InverseTransformLocation(const struct FTransform& T, const struct FVector& Location);
	static struct FRotator InverseTransformRotation(const struct FTransform& T, const struct FRotator& Rotation);
	static struct FTransform InvertTransform(const struct FTransform& T);
	static bool IsAfternoon(const struct FDateTime& A);
	static bool IsLeapYear(int32 Year);
	static bool IsMorning(const struct FDateTime& A);
	static bool IsNearlyZero2D(const struct FVector2D& A, float Tolerance);
	static bool IsPointInBox(const struct FVector& Point, const struct FVector& BoxOrigin, const struct FVector& BoxExtent);
	static bool IsPointInBox_Box(const struct FVector& Point, const struct FBox& Box);
	static bool IsPointInBoxWithTransform(const struct FVector& Point, const struct FTransform& BoxWorldTransform, const struct FVector& BoxExtent);
	static bool IsPointInBoxWithTransform_Box(const struct FVector& Point, const struct FTransform& BoxWorldTransform, const struct FBox& BoxExtent);
	static bool IsZero2D(const struct FVector2D& A);
	static double Lerp(double A, double B, double Alpha);
	static bool Less_ByteByte(uint8 A, uint8 B);
	static bool Less_DateTimeDateTime(const struct FDateTime& A, const struct FDateTime& B);
	static bool Less_DoubleDouble(double A, double B);
	static bool Less_Int64Int64(int64 A, int64 B);
	static bool Less_IntInt(int32 A, int32 B);
	static bool Less_TimespanTimespan(const struct FTimespan& A, const struct FTimespan& B);
	static bool LessEqual_ByteByte(uint8 A, uint8 B);
	static bool LessEqual_DateTimeDateTime(const struct FDateTime& A, const struct FDateTime& B);
	static bool LessEqual_DoubleDouble(double A, double B);
	static bool LessEqual_Int64Int64(int64 A, int64 B);
	static bool LessEqual_IntInt(int32 A, int32 B);
	static bool LessEqual_TimespanTimespan(const struct FTimespan& A, const struct FTimespan& B);
	static struct FVector LessLess_VectorRotator(const struct FVector& A, const struct FRotator& B);
	static struct FLinearColor LinearColor_Black();
	static struct FLinearColor LinearColor_Blue();
	static struct FLinearColor LinearColor_Desaturated(const struct FLinearColor& InColor, float InDesaturation);
	static float LinearColor_Distance(const struct FLinearColor& C1, const struct FLinearColor& C2);
	static float LinearColor_GetLuminance(const struct FLinearColor& InColor);
	static float LinearColor_GetMax(const struct FLinearColor& InColor);
	static float LinearColor_GetMin(const struct FLinearColor& InColor);
	static struct FLinearColor LinearColor_Gray();
	static struct FLinearColor LinearColor_Green();
	static bool LinearColor_IsNearEqual(const struct FLinearColor& A, const struct FLinearColor& B, float Tolerance);
	static struct FColor LinearColor_Quantize(const struct FLinearColor& InColor);
	static struct FColor LinearColor_QuantizeRound(const struct FLinearColor& InColor);
	static struct FLinearColor LinearColor_Red();
	static void LinearColor_Set(struct FLinearColor& InOutColor, const struct FLinearColor& InColor);
	static void LinearColor_SetFromHSV(struct FLinearColor& InOutColor, float H, float S, float V, float A);
	static void LinearColor_SetFromPow22(struct FLinearColor& InOutColor, const struct FColor& InColor);
	static void LinearColor_SetFromSRGB(struct FLinearColor& InOutColor, const struct FColor& InSRGB);
	static void LinearColor_SetRandomHue(struct FLinearColor& InOutColor);
	static void LinearColor_SetRGBA(struct FLinearColor& InOutColor, float R, float G, float B, float A);
	static void LinearColor_SetTemperature(struct FLinearColor& InOutColor, float InTemperature);
	static struct FLinearColor LinearColor_ToNewOpacity(const struct FLinearColor& InColor, float InOpacity);
	static struct FColor LinearColor_ToRGBE(const struct FLinearColor& InLinearColor);
	static struct FLinearColor LinearColor_Transparent();
	static struct FLinearColor LinearColor_White();
	static struct FLinearColor LinearColor_Yellow();
	static struct FLinearColor LinearColorLerp(const struct FLinearColor& A, const struct FLinearColor& B, float Alpha);
	static struct FLinearColor LinearColorLerpUsingHSV(const struct FLinearColor& A, const struct FLinearColor& B, float Alpha);
	static bool LinePlaneIntersection(const struct FVector& LineStart, const struct FVector& LineEnd, const struct FPlane& APlane, float* T, struct FVector* Intersection);
	static bool LinePlaneIntersection_OriginNormal(const struct FVector& LineStart, const struct FVector& LineEnd, const struct FVector& PlaneOrigin, const struct FVector& PlaneNormal, float* T, struct FVector* Intersection);
	static double Log(double A, double base);
	static double Loge(double A);
	static struct FBox MakeBox(const struct FVector& Min_0, const struct FVector& Max_0);
	static struct FBox2D MakeBox2D(const struct FVector2D& Min_0, const struct FVector2D& Max_0);
	static struct FBoxSphereBounds MakeBoxSphereBounds(const struct FVector& Origin, const struct FVector& BoxExtent, float SphereRadius);
	static struct FLinearColor MakeColor(float R, float G, float B, float A);
	static struct FDateTime MakeDateTime(int32 Year, int32 Month, int32 Day, int32 Hour, int32 Minute, int32 Second, int32 Millisecond);
	static struct FFrameRate MakeFrameRate(int32 Numerator, int32 Denominator);
	static struct FPlane MakePlaneFromPointAndNormal(const struct FVector& Point, const struct FVector& Normal_0);
	static float MakePulsatingValue(float InCurrentTime, float InPulsesPerSecond, float InPhase);
	static struct FQualifiedFrameTime MakeQualifiedFrameTime(const struct FFrameNumber& frame, const struct FFrameRate& FrameRate, float SubFrame);
	static struct FQuat MakeQuat(float X, float Y, float Z, float W);
	static struct FRandomStream MakeRandomStream(int32 InitialSeed);
	static struct FTransform MakeRelativeTransform(const struct FTransform& A, const struct FTransform& RelativeTo);
	static struct FRotator MakeRotationFromAxes(const struct FVector& Forward, const struct FVector& Right, const struct FVector& Up);
	static struct FRotator MakeRotator(float ROLL, float Pitch, float Yaw);
	static struct FRotator MakeRotFromX(const struct FVector& X);
	static struct FRotator MakeRotFromXY(const struct FVector& X, const struct FVector& Y);
	static struct FRotator MakeRotFromXZ(const struct FVector& X, const struct FVector& Z);
	static struct FRotator MakeRotFromY(const struct FVector& Y);
	static struct FRotator MakeRotFromYX(const struct FVector& Y, const struct FVector& X);
	static struct FRotator MakeRotFromYZ(const struct FVector& Y, const struct FVector& Z);
	static struct FRotator MakeRotFromZ(const struct FVector& Z);
	static struct FRotator MakeRotFromZX(const struct FVector& Z, const struct FVector& X);
	static struct FRotator MakeRotFromZY(const struct FVector& Z, const struct FVector& Y);
	static struct FTimespan MakeTimespan(int32 Days, int32 Hours, int32 Minutes, int32 Seconds, int32 Milliseconds);
	static struct FTimespan MakeTimespan2(int32 Days, int32 Hours, int32 Minutes, int32 Seconds, int32 FractionNano);
	static struct FTransform MakeTransform(const struct FVector& Location, const struct FRotator& Rotation, const struct FVector& Scale);
	static struct FVector MakeVector(double X, double Y, double Z);
	static struct FVector2D MakeVector2D(double X, double Y);
	static struct FVector4 MakeVector4(double X, double Y, double Z, double W);
	static struct FVector_NetQuantize MakeVector_NetQuantize(double X, double Y, double Z);
	static struct FVector_NetQuantize10 MakeVector_NetQuantize10(double X, double Y, double Z);
	static struct FVector_NetQuantize100 MakeVector_NetQuantize100(double X, double Y, double Z);
	static struct FVector_NetQuantizeNormal MakeVector_NetQuantizeNormal(double X, double Y, double Z);
	static double MapRangeClamped(double Value, double InRangeA, double InRangeB, double OutRangeA, double OutRangeB);
	static double MapRangeUnclamped(double Value, double InRangeA, double InRangeB, double OutRangeA, double OutRangeB);
	static struct FMatrix Matrix_ApplyScale(const struct FMatrix& M, float Scale);
	static struct FMatrix Matrix_ConcatenateTranslation(const struct FMatrix& M, const struct FVector& Translation);
	static bool Matrix_ContainsNaN(const struct FMatrix& M);
	static struct FVector Matrix_GetColumn(const struct FMatrix& M, EMatrixColumns Column);
	static float Matrix_GetDeterminant(const struct FMatrix& M);
	static bool Matrix_GetFrustumBottomPlane(const struct FMatrix& M, struct FPlane* OutPlane);
	static bool Matrix_GetFrustumFarPlane(const struct FMatrix& M, struct FPlane* OutPlane);
	static bool Matrix_GetFrustumLeftPlane(const struct FMatrix& M, struct FPlane* OutPlane);
	static bool Matrix_GetFrustumNearPlane(const struct FMatrix& M, struct FPlane* OutPlane);
	static bool Matrix_GetFrustumRightPlane(const struct FMatrix& M, struct FPlane* OutPlane);
	static bool Matrix_GetFrustumTopPlane(const struct FMatrix& M, struct FPlane* OutPlane);
	static struct FMatrix Matrix_GetInverse(const struct FMatrix& M);
	static struct FMatrix Matrix_GetMatrixWithoutScale(const struct FMatrix& M, float Tolerance);
	static float Matrix_GetMaximumAxisScale(const struct FMatrix& M);
	static struct FVector Matrix_GetOrigin(const struct FMatrix& InMatrix);
	static struct FRotator Matrix_GetRotator(const struct FMatrix& M);
	static float Matrix_GetRotDeterminant(const struct FMatrix& M);
	static void Matrix_GetScaledAxes(const struct FMatrix& M, struct FVector* X, struct FVector* Y, struct FVector* Z);
	static struct FVector Matrix_GetScaledAxis(const struct FMatrix& M, EAxis Axis);
	static struct FVector Matrix_GetScaleVector(const struct FMatrix& M, float Tolerance);
	static struct FMatrix Matrix_GetTransposeAdjoint(const struct FMatrix& M);
	static struct FMatrix Matrix_GetTransposed(const struct FMatrix& M);
	static void Matrix_GetUnitAxes(const struct FMatrix& M, struct FVector* X, struct FVector* Y, struct FVector* Z);
	static struct FVector Matrix_GetUnitAxis(const struct FMatrix& M, EAxis Axis);
	static struct FMatrix Matrix_Identity();
	static struct FVector Matrix_InverseTransformPosition(const struct FMatrix& M, const struct FVector& V);
	static struct FVector Matrix_InverseTransformVector(const struct FMatrix& M, const struct FVector& V);
	static struct FMatrix Matrix_Mirror(const struct FMatrix& M, EAxis MirrorAxis, EAxis FlipAxis);
	static void Matrix_RemoveScaling(struct FMatrix& M, float Tolerance);
	static struct FMatrix Matrix_RemoveTranslation(const struct FMatrix& M);
	static struct FMatrix Matrix_ScaleTranslation(const struct FMatrix& M, const struct FVector& Scale3D);
	static void Matrix_SetAxis(struct FMatrix& M, EAxis Axis, const struct FVector& AxisVector);
	static void Matrix_SetColumn(struct FMatrix& M, EMatrixColumns Column, const struct FVector& Value);
	static void Matrix_SetOrigin(struct FMatrix& M, const struct FVector& NewOrigin);
	static struct FQuat Matrix_ToQuat(const struct FMatrix& M);
	static struct FVector4 Matrix_TransformPosition(const struct FMatrix& M, const struct FVector& V);
	static struct FVector4 Matrix_TransformVector(const struct FMatrix& M, const struct FVector& V);
	static struct FVector4 Matrix_TransformVector4(const struct FMatrix& M, const struct FVector4& V);
	static int32 Max(int32 A, int32 B);
	static int64 MaxInt64(int64 A, int64 B);
	static void MaxOfByteArray(const TArray<uint8>& ByteArray, int32* IndexOfMaxValue, uint8* MaxValue);
	static void MaxOfFloatArray(const TArray<float>& FloatArray, int32* IndexOfMaxValue, float* MaxValue);
	static void MaxOfIntArray(const TArray<int32>& IntArray, int32* IndexOfMaxValue, int32* MaxValue);
	static void MedianOfIntArray(const TArray<int32>& IntArray, float* MedianValue);
	static int32 Min(int32 A, int32 B);
	static void MinAreaRectangle(class UObject* WorldContextObject, const TArray<struct FVector>& InPoints, const struct FVector& SampleSurfaceNormal, struct FVector* OutRectCenter, struct FRotator* OutRectRotation, float* OutRectLengthX, float* OutRectLengthY, bool bDebugDraw);
	static void MinimumAreaRectangle(class UObject* WorldContextObject, const TArray<struct FVector>& InVerts, const struct FVector& SampleSurfaceNormal, struct FVector* OutRectCenter, struct FRotator* OutRectRotation, float* OutSideLengthX, float* OutSideLengthY, bool bDebugDraw);
	static int64 MinInt64(int64 A, int64 B);
	static void MinOfByteArray(const TArray<uint8>& ByteArray, int32* IndexOfMinValue, uint8* MinValue);
	static void MinOfFloatArray(const TArray<float>& FloatArray, int32* IndexOfMinValue, float* MinValue);
	static void MinOfIntArray(const TArray<int32>& IntArray, int32* IndexOfMinValue, int32* MinValue);
	static struct FVector MirrorVectorByNormal(const struct FVector& InVect, const struct FVector& InNormal);
	static uint8 Multiply_ByteByte(uint8 A, uint8 B);
	static double Multiply_DoubleDouble(double A, double B);
	static int64 Multiply_Int64Int64(int64 A, int64 B);
	static double Multiply_IntFloat(int32 A, double B);
	static int32 Multiply_IntInt(int32 A, int32 B);
	static struct FIntPoint Multiply_IntPointInt(const struct FIntPoint& A, int32 B);
	static struct FIntPoint Multiply_IntPointIntPoint(const struct FIntPoint& A, const struct FIntPoint& B);
	static struct FLinearColor Multiply_LinearColorFloat(const struct FLinearColor& A, float B);
	static struct FLinearColor Multiply_LinearColorLinearColor(const struct FLinearColor& A, const struct FLinearColor& B);
	static struct FMatrix Multiply_MatrixFloat(const struct FMatrix& A, double B);
	static struct FMatrix Multiply_MatrixMatrix(const struct FMatrix& A, const struct FMatrix& B);
	static struct FQuat Multiply_QuatQuat(const struct FQuat& A, const struct FQuat& B);
	static struct FRotator Multiply_RotatorFloat(const struct FRotator& A, float B);
	static struct FRotator Multiply_RotatorInt(const struct FRotator& A, int32 B);
	static struct FTimespan Multiply_TimespanFloat(const struct FTimespan& A, float Scalar);
	static struct FVector2D Multiply_Vector2DFloat(const struct FVector2D& A, double B);
	static struct FVector2D Multiply_Vector2DVector2D(const struct FVector2D& A, const struct FVector2D& B);
	static struct FVector4 Multiply_Vector4Vector4(const struct FVector4& A, const struct FVector4& B);
	static struct FVector Multiply_VectorFloat(const struct FVector& A, double B);
	static struct FVector Multiply_VectorInt(const struct FVector& A, int32 B);
	static struct FVector Multiply_VectorVector(const struct FVector& A, const struct FVector& B);
	static double MultiplyByPi(double Value);
	static double MultiplyMultiply_FloatFloat(double base, double Exp);
	static bool NearlyEqual_FloatFloat(double A, double B, double ErrorTolerance);
	static bool NearlyEqual_TransformTransform(const struct FTransform& A, const struct FTransform& B, float LocationTolerance, float RotationTolerance, float Scale3DTolerance);
	static struct FVector2D Negated2D(const struct FVector2D& A);
	static struct FRotator NegateRotator(const struct FRotator& A);
	static struct FVector NegateVector(const struct FVector& A);
	static struct FVector Normal(const struct FVector& A, float Tolerance);
	static struct FVector2D Normal2D(const struct FVector2D& A);
	static void Normalize2D(struct FVector2D& A, float Tolerance);
	static float NormalizeAxis(float Angle);
	static struct FRotator NormalizedDeltaRotator(const struct FRotator& A, const struct FRotator& B);
	static double NormalizeToRange(double Value, double RangeMin, double RangeMax);
	static struct FVector2D NormalSafe2D(const struct FVector2D& A, float Tolerance);
	static int32 Not_Int(int32 A);
	static int64 Not_Int64(int64 A);
	static bool Not_PreBool(bool A);
	static bool NotEqual_BoolBool(bool A, bool B);
	static bool NotEqual_ByteByte(uint8 A, uint8 B);
	static bool NotEqual_ClassClass(class UClass* A, class UClass* B);
	static bool NotEqual_DateTimeDateTime(const struct FDateTime& A, const struct FDateTime& B);
	static bool NotEqual_DoubleDouble(double A, double B);
	static bool NotEqual_Int64Int64(int64 A, int64 B);
	static bool NotEqual_IntInt(int32 A, int32 B);
	static bool NotEqual_IntPointIntPoint(const struct FIntPoint& A, const struct FIntPoint& B);
	static bool NotEqual_LinearColorLinearColor(const struct FLinearColor& A, const struct FLinearColor& B);
	static bool NotEqual_MatrixMatrix(const struct FMatrix& A, const struct FMatrix& B, float Tolerance);
	static bool NotEqual_NameName(class FName A, class FName B);
	static bool NotEqual_ObjectObject(class UObject* A, class UObject* B);
	static bool NotEqual_QuatQuat(const struct FQuat& A, const struct FQuat& B, float ErrorTolerance);
	static bool NotEqual_RotatorRotator(const struct FRotator& A, const struct FRotator& B, float ErrorTolerance);
	static bool NotEqual_TimespanTimespan(const struct FTimespan& A, const struct FTimespan& B);
	static bool NotEqual_Vector2DVector2D(const struct FVector2D& A, const struct FVector2D& B, float ErrorTolerance);
	static bool NotEqual_Vector4Vector4(const struct FVector4& A, const struct FVector4& B, float ErrorTolerance);
	static bool NotEqual_VectorVector(const struct FVector& A, const struct FVector& B, float ErrorTolerance);
	static bool NotEqualExactly_Vector2DVector2D(const struct FVector2D& A, const struct FVector2D& B);
	static bool NotEqualExactly_Vector4Vector4(const struct FVector4& A, const struct FVector4& B);
	static bool NotEqualExactly_VectorVector(const struct FVector& A, const struct FVector& B);
	static struct FDateTime Now();
	static int64 Or_Int64Int64(int64 A, int64 B);
	static int32 Or_IntInt(int32 A, int32 B);
	static uint8 Percent_ByteByte(uint8 A, uint8 B);
	static double Percent_FloatFloat(double A, double B);
	static int64 Percent_Int64Int64(int64 A, int64 B);
	static int32 Percent_IntInt(int32 A, int32 B);
	static float PerlinNoise1D(const float Value);
	static bool PointsAreCoplanar(const TArray<struct FVector>& Points, float Tolerance);
	static struct FVector ProjectPointOnToPlane(const struct FVector& Point, const struct FVector& PlaneBase, const struct FVector& PlaneNormal);
	static struct FVector ProjectVectorOnToPlane(const struct FVector& V, const struct FVector& PlaneNormal);
	static struct FVector ProjectVectorOnToVector(const struct FVector& V, const struct FVector& Target);
	static float Quat_AngularDistance(const struct FQuat& A, const struct FQuat& B);
	static void Quat_EnforceShortestArcWith(struct FQuat& A, const struct FQuat& B);
	static struct FVector Quat_Euler(const struct FQuat& Q);
	static struct FQuat Quat_Exp(const struct FQuat& Q);
	static struct FQuat Quat_FindBetweenNormals(const struct FVector& StartNormal, const struct FVector& EndNormal);
	static struct FQuat Quat_FindBetweenVectors(const struct FVector& START, const struct FVector& End);
	static float Quat_GetAngle(const struct FQuat& Q);
	static struct FVector Quat_GetAxisX(const struct FQuat& Q);
	static struct FVector Quat_GetAxisY(const struct FQuat& Q);
	static struct FVector Quat_GetAxisZ(const struct FQuat& Q);
	static struct FVector Quat_GetRotationAxis(const struct FQuat& Q);
	static struct FQuat Quat_Identity();
	static struct FQuat Quat_Inversed(const struct FQuat& Q);
	static bool Quat_IsFinite(const struct FQuat& Q);
	static bool Quat_IsIdentity(const struct FQuat& Q, float Tolerance);
	static bool Quat_IsNonFinite(const struct FQuat& Q);
	static bool Quat_IsNormalized(const struct FQuat& Q);
	static struct FQuat Quat_Log(const struct FQuat& Q);
	static struct FQuat Quat_MakeFromEuler(const struct FVector& Euler);
	static void Quat_Normalize(struct FQuat& Q, float Tolerance);
	static struct FQuat Quat_Normalized(const struct FQuat& Q, float Tolerance);
	static struct FVector Quat_RotateVector(const struct FQuat& Q, const struct FVector& V);
	static struct FRotator Quat_Rotator(const struct FQuat& Q);
	static void Quat_SetComponents(struct FQuat& Q, float X, float Y, float Z, float W);
	static void Quat_SetFromEuler(struct FQuat& Q, const struct FVector& Euler);
	static float Quat_Size(const struct FQuat& Q);
	static float Quat_SizeSquared(const struct FQuat& Q);
	static struct FQuat Quat_Slerp(const struct FQuat& A, const struct FQuat& B, double Alpha);
	static struct FVector Quat_UnrotateVector(const struct FQuat& Q, const struct FVector& V);
	static struct FVector Quat_VectorForward(const struct FQuat& Q);
	static struct FVector Quat_VectorRight(const struct FQuat& Q);
	static struct FVector Quat_VectorUp(const struct FQuat& Q);
	static struct FQuat QuaternionSpringInterp(const struct FQuat& Current, const struct FQuat& Target, struct FQuaternionSpringState& SpringState, float Stiffness, float CriticalDampingFactor, float DeltaTime, float Mass, float TargetVelocityAmount, bool bInitializeFromTarget);
	static double RadiansToDegrees(double A);
	static bool RandomBool();
	static bool RandomBoolFromStream(const struct FRandomStream& Stream);
	static bool RandomBoolWithWeight(float Weight);
	static bool RandomBoolWithWeightFromStream(const struct FRandomStream& RandomStream, float Weight);
	static double RandomFloat();
	static float RandomFloatFromStream(const struct FRandomStream& Stream);
	static double RandomFloatInRange(double Min, double Max);
	static float RandomFloatInRangeFromStream(const struct FRandomStream& Stream, float Min, float Max);
	static int32 RandomInteger(int32 Max);
	static int64 RandomInteger64(int64 Max);
	static int64 RandomInteger64InRange(int64 Min, int64 Max);
	static int32 RandomIntegerFromStream(const struct FRandomStream& Stream, int32 Max);
	static int32 RandomIntegerInRange(int32 Min, int32 Max);
	static int32 RandomIntegerInRangeFromStream(const struct FRandomStream& Stream, int32 Min, int32 Max);
	static struct FVector RandomPointInBoundingBox(const struct FVector& Center, const struct FVector& HalfSize);
	static struct FVector RandomPointInBoundingBox_Box(const struct FBox& Box);
	static struct FVector RandomPointInBoundingBoxFromStream(const struct FRandomStream& Stream, const struct FVector& Center, const struct FVector& HalfSize);
	static struct FVector RandomPointInBoundingBoxFromStream_Box(const struct FRandomStream& Stream, const struct FBox& Box);
	static struct FRotator RandomRotator(bool bRoll);
	static struct FRotator RandomRotatorFromStream(const struct FRandomStream& Stream, bool bRoll);
	static struct FVector RandomUnitVector();
	static struct FVector RandomUnitVectorFromStream(const struct FRandomStream& Stream);
	static struct FVector RandomUnitVectorInConeInDegrees(const struct FVector& ConeDir, float ConeHalfAngleInDegrees);
	static struct FVector RandomUnitVectorInConeInDegreesFromStream(const struct FRandomStream& Stream, const struct FVector& ConeDir, float ConeHalfAngleInDegrees);
	static struct FVector RandomUnitVectorInConeInRadians(const struct FVector& ConeDir, float ConeHalfAngleInRadians);
	static struct FVector RandomUnitVectorInConeInRadiansFromStream(const struct FRandomStream& Stream, const struct FVector& ConeDir, float ConeHalfAngleInRadians);
	static struct FVector RandomUnitVectorInEllipticalConeInDegrees(const struct FVector& ConeDir, float MaxYawInDegrees, float MaxPitchInDegrees);
	static struct FVector RandomUnitVectorInEllipticalConeInDegreesFromStream(const struct FRandomStream& Stream, const struct FVector& ConeDir, float MaxYawInDegrees, float MaxPitchInDegrees);
	static struct FVector RandomUnitVectorInEllipticalConeInRadians(const struct FVector& ConeDir, float MaxYawInRadians, float MaxPitchInRadians);
	static struct FVector RandomUnitVectorInEllipticalConeInRadiansFromStream(const struct FRandomStream& Stream, const struct FVector& ConeDir, float MaxYawInRadians, float MaxPitchInRadians);
	static struct FRotator REase(const struct FRotator& A, const struct FRotator& B, float Alpha, bool bShortestPath, EEasingFunc EasingFunc, float BlendExp, int32 Steps);
	static void ResetFloatSpringState(struct FFloatSpringState& SpringState);
	static void ResetQuaternionSpringState(struct FQuaternionSpringState& SpringState);
	static void ResetRandomStream(const struct FRandomStream& Stream);
	static void ResetVectorSpringState(struct FVectorSpringState& SpringState);
	static struct FLinearColor RGBLinearToHSV(const struct FLinearColor& RGB);
	static void RGBToHSV(const struct FLinearColor& InColor, float* H, float* S, float* V, float* A);
	static void RGBToHSV_Vector(const struct FLinearColor& RGB, struct FLinearColor* HSV);
	static struct FRotator RInterpTo(const struct FRotator& Current, const struct FRotator& Target, float DeltaTime, float InterpSpeed);
	static struct FRotator RInterpTo_Constant(const struct FRotator& Current, const struct FRotator& Target, float DeltaTime, float InterpSpeed);
	static struct FRotator RLerp(const struct FRotator& A, const struct FRotator& B, float Alpha, bool bShortestPath);
	static struct FVector RotateAngleAxis(const struct FVector& InVect, float AngleDeg, const struct FVector& Axis);
	static struct FRotator RotatorFromAxisAndAngle(const struct FVector& Axis, float Angle);
	static int32 Round(double A);
	static int64 Round64(double A);
	static double SafeDivide(double A, double B);
	static void SeedRandomStream(struct FRandomStream& Stream);
	static class UClass* SelectClass(class UClass* A, class UClass* B, bool bSelectA);
	static struct FLinearColor SelectColor(const struct FLinearColor& A, const struct FLinearColor& B, bool bPickA);
	static double SelectFloat(double A, double B, bool bPickA);
	static int32 SelectInt(int32 A, int32 B, bool bPickA);
	static class UObject* SelectObject(class UObject* A, class UObject* B, bool bSelectA);
	static struct FRotator SelectRotator(const struct FRotator& A, const struct FRotator& B, bool bPickA);
	static class FString SelectString(const class FString& A, const class FString& B, bool bPickA);
	static struct FTransform SelectTransform(const struct FTransform& A, const struct FTransform& B, bool bPickA);
	static struct FVector SelectVector(const struct FVector& A, const struct FVector& B, bool bPickA);
	static void Set2D(struct FVector2D& A, double X, double Y);
	static void SetFloatSpringStateVelocity(struct FFloatSpringState& SpringState, float Velocity);
	static void SetQuaternionSpringStateAngularVelocity(struct FQuaternionSpringState& SpringState, const struct FVector& AngularVelocity);
	static void SetRandomStreamSeed(struct FRandomStream& Stream, int32 NewSeed);
	static void SetVectorSpringStateVelocity(struct FVectorSpringState& SpringState, const struct FVector& Velocity);
	static double SignOfFloat(double A);
	static int32 SignOfInteger(int32 A);
	static int64 SignOfInteger64(int64 A);
	static double Sin(double A);
	static struct FVector Spherical2DToUnitCartesian(const struct FVector2D& A);
	static double Sqrt(double A);
	static double Square(double A);
	static uint8 Subtract_ByteByte(uint8 A, uint8 B);
	static struct FTimespan Subtract_DateTimeDateTime(const struct FDateTime& A, const struct FDateTime& B);
	static struct FDateTime Subtract_DateTimeTimespan(const struct FDateTime& A, const struct FTimespan& B);
	static double Subtract_DoubleDouble(double A, double B);
	static int64 Subtract_Int64Int64(int64 A, int64 B);
	static int32 Subtract_IntInt(int32 A, int32 B);
	static struct FIntPoint Subtract_IntPointInt(const struct FIntPoint& A, int32 B);
	static struct FIntPoint Subtract_IntPointIntPoint(const struct FIntPoint& A, const struct FIntPoint& B);
	static struct FLinearColor Subtract_LinearColorLinearColor(const struct FLinearColor& A, const struct FLinearColor& B);
	static struct FQuat Subtract_QuatQuat(const struct FQuat& A, const struct FQuat& B);
	static struct FTimespan Subtract_TimespanTimespan(const struct FTimespan& A, const struct FTimespan& B);
	static struct FVector2D Subtract_Vector2DFloat(const struct FVector2D& A, double B);
	static struct FVector2D Subtract_Vector2DVector2D(const struct FVector2D& A, const struct FVector2D& B);
	static struct FVector4 Subtract_Vector4Vector4(const struct FVector4& A, const struct FVector4& B);
	static struct FVector Subtract_VectorFloat(const struct FVector& A, double B);
	static struct FVector Subtract_VectorInt(const struct FVector& A, int32 B);
	static struct FVector Subtract_VectorVector(const struct FVector& A, const struct FVector& B);
	static double Tan(double A);
	static struct FTransform TEase(const struct FTransform& A, const struct FTransform& B, float Alpha, EEasingFunc EasingFunc, float BlendExp, int32 Steps);
	static bool TimespanFromString(const class FString& TimespanString, struct FTimespan* Result);
	static struct FTimespan TimespanMaxValue();
	static struct FTimespan TimespanMinValue();
	static float TimespanRatio(const struct FTimespan& A, const struct FTimespan& B);
	static struct FTimespan TimespanZeroValue();
	static struct FTransform TInterpTo(const struct FTransform& Current, const struct FTransform& Target, float DeltaTime, float InterpSpeed);
	static struct FTransform TLerp(const struct FTransform& A, const struct FTransform& B, float Alpha, ELerpInterpolationMode InterpMode);
	static struct FDateTime Today();
	static void ToDirectionAndLength2D(const struct FVector2D& A, struct FVector2D* OutDir, double* OutLength);
	static class FString ToHex_LinearColor(const struct FLinearColor& InColor);
	static struct FVector2D ToRounded2D(const struct FVector2D& A);
	static struct FVector2D ToSign2D(const struct FVector2D& A);
	static int64 ToUnixTimestamp(const struct FDateTime& Time);
	static double ToUnixTimestampDouble(const struct FDateTime& Time);
	static float Transform_Determinant(const struct FTransform& Transform);
	static struct FVector TransformDirection(const struct FTransform& T, const struct FVector& Direction);
	static struct FVector TransformLocation(const struct FTransform& T, const struct FVector& Location);
	static struct FRotator TransformRotation(const struct FTransform& T, const struct FRotator& Rotation);
	static struct FVector4 TransformVector4(const struct FMatrix& Matrix, const struct FVector4& Vec4);
	static struct FDateTime UtcNow();
	static struct FVector VEase(const struct FVector& A, const struct FVector& B, float Alpha, EEasingFunc EasingFunc, float BlendExp, int32 Steps);
	static struct FVector2D Vector2D_One();
	static struct FVector2D Vector2D_Unit45Deg();
	static struct FVector2D Vector2D_Zero();
	static struct FVector2D Vector2DInterpTo(const struct FVector2D& Current, const struct FVector2D& Target, float DeltaTime, float InterpSpeed);
	static struct FVector2D Vector2DInterpTo_Constant(const struct FVector2D& Current, const struct FVector2D& Target, float DeltaTime, float InterpSpeed);
	static void Vector4_Assign(struct FVector4& A, const struct FVector4& InVector);
	static struct FVector4 Vector4_CrossProduct3(const struct FVector4& A, const struct FVector4& B);
	static double Vector4_DotProduct(const struct FVector4& A, const struct FVector4& B);
	static double Vector4_DotProduct3(const struct FVector4& A, const struct FVector4& B);
	static bool Vector4_IsNAN(const struct FVector4& A);
	static bool Vector4_IsNearlyZero3(const struct FVector4& A, float Tolerance);
	static bool Vector4_IsNormal3(const struct FVector4& A);
	static bool Vector4_IsUnit3(const struct FVector4& A, float SquaredLenthTolerance);
	static bool Vector4_IsZero(const struct FVector4& A);
	static struct FVector4 Vector4_MirrorByVector3(const struct FVector4& Direction, const struct FVector4& SurfaceNormal);
	static struct FVector4 Vector4_Negated(const struct FVector4& A);
	static struct FVector4 Vector4_Normal3(const struct FVector4& A, float Tolerance);
	static void Vector4_Normalize3(struct FVector4& A, float Tolerance);
	static struct FVector4 Vector4_NormalUnsafe3(const struct FVector4& A);
	static void Vector4_Set(struct FVector4& A, double X, double Y, double Z, double W);
	static double Vector4_Size(const struct FVector4& A);
	static double Vector4_Size3(const struct FVector4& A);
	static double Vector4_SizeSquared(const struct FVector4& A);
	static double Vector4_SizeSquared3(const struct FVector4& A);
	static struct FVector4 Vector4_Zero();
	static void Vector_AddBounded(struct FVector& A, const struct FVector& InAddVect, float InRadius);
	static void Vector_Assign(struct FVector& A, const struct FVector& InVector);
	static struct FVector Vector_Backward();
	static struct FVector Vector_BoundedToBox(const struct FVector& InVect, const struct FVector& InBoxMin, const struct FVector& InBoxMax);
	static struct FVector Vector_BoundedToCube(const struct FVector& InVect, float InRadius);
	static struct FVector Vector_ClampSize2D(const struct FVector& A, double Min, double Max);
	static struct FVector Vector_ClampSizeMax(const struct FVector& A, double Max);
	static struct FVector Vector_ClampSizeMax2D(const struct FVector& A, double Max);
	static struct FVector Vector_ComponentMax(const struct FVector& A, const struct FVector& B);
	static struct FVector Vector_ComponentMin(const struct FVector& A, const struct FVector& B);
	static double Vector_CosineAngle2D(const struct FVector& A, const struct FVector& B);
	static double Vector_Distance(const struct FVector& v1, const struct FVector& v2);
	static double Vector_Distance2D(const struct FVector& v1, const struct FVector& v2);
	static double Vector_Distance2DSquared(const struct FVector& v1, const struct FVector& v2);
	static double Vector_DistanceSquared(const struct FVector& v1, const struct FVector& v2);
	static struct FVector Vector_Down();
	static struct FVector Vector_Forward();
	static struct FVector Vector_GetAbs(const struct FVector& A);
	static double Vector_GetAbsMax(const struct FVector& A);
	static double Vector_GetAbsMin(const struct FVector& A);
	static struct FVector Vector_GetProjection(const struct FVector& A);
	static struct FVector Vector_GetSignVector(const struct FVector& A);
	static double Vector_HeadingAngle(const struct FVector& A);
	static bool Vector_IsNAN(const struct FVector& A);
	static bool Vector_IsNearlyZero(const struct FVector& A, float Tolerance);
	static bool Vector_IsNormal(const struct FVector& A);
	static bool Vector_IsUniform(const struct FVector& A, float Tolerance);
	static bool Vector_IsUnit(const struct FVector& A, float SquaredLenthTolerance);
	static bool Vector_IsZero(const struct FVector& A);
	static struct FVector Vector_Left();
	static struct FVector Vector_MirrorByPlane(const struct FVector& A, const struct FPlane& InPlane);
	static struct FVector Vector_Normal2D(const struct FVector& A, float Tolerance);
	static void Vector_Normalize(struct FVector& A, float Tolerance);
	static struct FVector Vector_NormalUnsafe(const struct FVector& A);
	static struct FVector Vector_One();
	static struct FVector Vector_ProjectOnToNormal(const struct FVector& V, const struct FVector& InNormal);
	static struct FVector Vector_Reciprocal(const struct FVector& A);
	static struct FVector Vector_Right();
	static void Vector_Set(struct FVector& A, double X, double Y, double Z);
	static struct FVector Vector_SlerpNormals(const struct FVector& NormalA, const struct FVector& NormalB, double Alpha);
	static struct FVector Vector_SlerpVectorToDirection(const struct FVector& Vector, const struct FVector& Direction, double Alpha);
	static struct FVector Vector_SnappedToGrid(const struct FVector& InVect, float InGridSize);
	static struct FVector Vector_ToDegrees(const struct FVector& A);
	static struct FVector Vector_ToRadians(const struct FVector& A);
	static struct FVector2D Vector_UnitCartesianToSpherical(const struct FVector& A);
	static void Vector_UnwindEuler(struct FVector& A);
	static struct FVector Vector_Up();
	static struct FVector Vector_Zero();
	static struct FVector VectorSpringInterp(const struct FVector& Current, const struct FVector& Target, struct FVectorSpringState& SpringState, float Stiffness, float CriticalDampingFactor, float DeltaTime, float Mass, float TargetVelocityAmount, bool bClamp, const struct FVector& MinValue, const struct FVector& MaxValue, bool bInitializeFromTarget);
	static struct FVector VInterpTo(const struct FVector& Current, const struct FVector& Target, float DeltaTime, float InterpSpeed);
	static struct FVector VInterpTo_Constant(const struct FVector& Current, const struct FVector& Target, float DeltaTime, float InterpSpeed);
	static struct FVector VLerp(const struct FVector& A, const struct FVector& B, float Alpha);
	static double VSize(const struct FVector& A);
	static double VSize2D(const struct FVector2D& A);
	static double VSize2DSquared(const struct FVector2D& A);
	static double VSizeSquared(const struct FVector& A);
	static double VSizeXY(const struct FVector& A);
	static double VSizeXYSquared(const struct FVector& A);
	static float WeightedMovingAverage_Float(float CurrentSample, float PreviousSample, float Weight);
	static struct FRotator WeightedMovingAverage_FRotator(const struct FRotator& CurrentSample, const struct FRotator& PreviousSample, float Weight);
	static struct FVector WeightedMovingAverage_FVector(const struct FVector& CurrentSample, const struct FVector& PreviousSample, float Weight);
	static int32 Wrap(int32 Value, int32 Min, int32 Max);
	static int64 Xor_Int64Int64(int64 A, int64 B);
	static int32 Xor_IntInt(int32 A, int32 B);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"KismetMathLibrary">();
	}
	static class UKismetMathLibrary* GetDefaultObj()
	{
		return GetDefaultObjImpl<UKismetMathLibrary>();
	}
};
static_assert(alignof(UKismetMathLibrary) == 0x000008, "Wrong alignment on UKismetMathLibrary");
static_assert(sizeof(UKismetMathLibrary) == 0x000028, "Wrong size on UKismetMathLibrary");

// Class Engine.KismetRenderingLibrary
// 0x0000 (0x0028 - 0x0028)
class UKismetRenderingLibrary final : public UBlueprintFunctionLibrary
{
public:
	static void BeginDrawCanvasToRenderTarget(class UObject* WorldContextObject, class UTextureRenderTarget2D* TextureRenderTarget, class UCanvas** Canvas, struct FVector2D* Size, struct FDrawToRenderTargetContext* Context);
	static void BreakSkinWeightInfo(const struct FSkelMeshSkinWeightInfo& InWeight, int32* Bone0, uint8* Weight0, int32* Bone1, uint8* Weight1, int32* Bone2, uint8* Weight2, int32* Bone3, uint8* Weight3);
	static struct FMatrix CalculateProjectionMatrix(const struct FMinimalViewInfo& MinimalViewInfo);
	static void ClearRenderTarget2D(class UObject* WorldContextObject, class UTextureRenderTarget2D* TextureRenderTarget, const struct FLinearColor& ClearColor);
	static void ConvertRenderTargetToTexture2DEditorOnly(class UObject* WorldContextObject, class UTextureRenderTarget2D* RenderTarget, class UTexture2D* Texture);
	static class UTextureRenderTarget2D* CreateRenderTarget2D(class UObject* WorldContextObject, int32 Width, int32 Height, ETextureRenderTargetFormat Format, const struct FLinearColor& ClearColor, bool bAutoGenerateMipMaps, bool bSupportUAVs);
	static class UTextureRenderTarget2DArray* CreateRenderTarget2DArray(class UObject* WorldContextObject, int32 Width, int32 Height, int32 Slices, ETextureRenderTargetFormat Format, const struct FLinearColor& ClearColor, bool bAutoGenerateMipMaps, bool bSupportUAVs);
	static class UTextureRenderTargetVolume* CreateRenderTargetVolume(class UObject* WorldContextObject, int32 Width, int32 Height, int32 Depth, ETextureRenderTargetFormat Format, const struct FLinearColor& ClearColor, bool bAutoGenerateMipMaps, bool bSupportUAVs);
	static void DrawMaterialToRenderTarget(class UObject* WorldContextObject, class UTextureRenderTarget2D* TextureRenderTarget, class UMaterialInterface* Material);
	static void EnablePathTracing(bool bEnablePathTracer);
	static void EndDrawCanvasToRenderTarget(class UObject* WorldContextObject, const struct FDrawToRenderTargetContext& Context);
	static void ExportRenderTarget(class UObject* WorldContextObject, class UTextureRenderTarget2D* TextureRenderTarget, const class FString& FilePath, const class FString& Filename);
	static void ExportTexture2D(class UObject* WorldContextObject, class UTexture2D* Texture, const class FString& FilePath, const class FString& Filename);
	static class UTexture2D* ImportBufferAsTexture2D(class UObject* WorldContextObject, const TArray<uint8>& Buffer);
	static class UTexture2D* ImportFileAsTexture2D(class UObject* WorldContextObject, const class FString& Filename);
	static struct FSkelMeshSkinWeightInfo MakeSkinWeightInfo(int32 Bone0, uint8 Weight0, int32 Bone1, uint8 Weight1, int32 Bone2, uint8 Weight2, int32 Bone3, uint8 Weight3);
	static bool ReadRenderTarget(class UObject* WorldContextObject, class UTextureRenderTarget2D* TextureRenderTarget, TArray<struct FColor>* OutSamples, bool bNormalize);
	static struct FColor ReadRenderTargetPixel(class UObject* WorldContextObject, class UTextureRenderTarget2D* TextureRenderTarget, int32 X, int32 Y);
	static bool ReadRenderTargetRaw(class UObject* WorldContextObject, class UTextureRenderTarget2D* TextureRenderTarget, TArray<struct FLinearColor>* OutLinearSamples, bool bNormalize);
	static struct FLinearColor ReadRenderTargetRawPixel(class UObject* WorldContextObject, class UTextureRenderTarget2D* TextureRenderTarget, int32 X, int32 Y, bool bNormalize);
	static TArray<struct FLinearColor> ReadRenderTargetRawPixelArea(class UObject* WorldContextObject, class UTextureRenderTarget2D* TextureRenderTarget, int32 MinX, int32 MinY, int32 MaxX, int32 MaxY, bool bNormalize);
	static struct FLinearColor ReadRenderTargetRawUV(class UObject* WorldContextObject, class UTextureRenderTarget2D* TextureRenderTarget, float U, float V, bool bNormalize);
	static TArray<struct FLinearColor> ReadRenderTargetRawUVArea(class UObject* WorldContextObject, class UTextureRenderTarget2D* TextureRenderTarget, const struct FBox2D& Area, bool bNormalize);
	static struct FColor ReadRenderTargetUV(class UObject* WorldContextObject, class UTextureRenderTarget2D* TextureRenderTarget, float U, float V);
	static void RefreshPathTracingOutput();
	static void ReleaseRenderTarget2D(class UTextureRenderTarget2D* TextureRenderTarget);
	static class UTexture2D* RenderTargetCreateStaticTexture2DEditorOnly(class UTextureRenderTarget2D* RenderTarget, const class FString& Name_0, ETextureCompressionSettings CompressionSettings, ETextureMipGenSettings MipSettings);
	static void ResizeRenderTarget2D(class UTextureRenderTarget2D* TextureRenderTarget, int32 Width, int32 Height);
	static void SetCastInsetShadowForAllAttachments(class UPrimitiveComponent* PrimitiveComponent, bool bCastInsetShadow, bool bLightAttachmentsAsGroup);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"KismetRenderingLibrary">();
	}
	static class UKismetRenderingLibrary* GetDefaultObj()
	{
		return GetDefaultObjImpl<UKismetRenderingLibrary>();
	}
};
static_assert(alignof(UKismetRenderingLibrary) == 0x000008, "Wrong alignment on UKismetRenderingLibrary");
static_assert(sizeof(UKismetRenderingLibrary) == 0x000028, "Wrong size on UKismetRenderingLibrary");

// Class Engine.KismetStringLibrary
// 0x0000 (0x0028 - 0x0028)
class UKismetStringLibrary final : public UBlueprintFunctionLibrary
{
public:
	static class FString BuildString_Bool(const class FString& AppendTo, const class FString& Prefix, bool InBool, const class FString& Suffix);
	static class FString BuildString_Color(const class FString& AppendTo, const class FString& Prefix, const struct FLinearColor& InColor, const class FString& Suffix);
	static class FString BuildString_Double(const class FString& AppendTo, const class FString& Prefix, double InDouble, const class FString& Suffix);
	static class FString BuildString_Int(const class FString& AppendTo, const class FString& Prefix, int32 inInt, const class FString& Suffix);
	static class FString BuildString_IntVector(const class FString& AppendTo, const class FString& Prefix, const struct FIntVector& InIntVector, const class FString& Suffix);
	static class FString BuildString_Name(const class FString& AppendTo, const class FString& Prefix, class FName InName, const class FString& Suffix);
	static class FString BuildString_Object(const class FString& AppendTo, const class FString& Prefix, class UObject* InObj, const class FString& Suffix);
	static class FString BuildString_Rotator(const class FString& AppendTo, const class FString& Prefix, const struct FRotator& InRot, const class FString& Suffix);
	static class FString BuildString_Vector(const class FString& AppendTo, const class FString& Prefix, const struct FVector& InVector, const class FString& Suffix);
	static class FString BuildString_Vector2d(const class FString& AppendTo, const class FString& Prefix, const struct FVector2D& InVector2D, const class FString& Suffix);
	static class FString Concat_StrStr(const class FString& A, const class FString& B);
	static bool Contains(const class FString& SearchIn, const class FString& Substring, bool bUseCase, bool bSearchFromEnd);
	static class FString Conv_BoolToString(bool InBool);
	static class FString Conv_ByteToString(uint8 InByte);
	static class FString Conv_ColorToString(const struct FLinearColor& InColor);
	static class FString Conv_DoubleToString(double InDouble);
	static class FString Conv_InputDeviceIdToString(const struct FInputDeviceId& InDeviceId);
	static class FString Conv_Int64ToString(int64 inInt);
	static class FString Conv_IntPointToString(const struct FIntPoint& InIntPoint);
	static class FString Conv_IntToString(int32 inInt);
	static class FString Conv_IntVectorToString(const struct FIntVector& InIntVec);
	static class FString Conv_MatrixToString(const struct FMatrix& InMatrix);
	static class FString Conv_NameToString(class FName InName);
	static class FString Conv_ObjectToString(class UObject* InObj);
	static class FString Conv_PlatformUserIdToString(const struct FPlatformUserId& InPlatformUserId);
	static class FString Conv_RotatorToString(const struct FRotator& InRot);
	static void Conv_StringToColor(const class FString& InString, struct FLinearColor* OutConvertedColor, bool* OutIsValid);
	static double Conv_StringToDouble(const class FString& InString);
	static int32 Conv_StringToInt(const class FString& InString);
	static int64 Conv_StringToInt64(const class FString& InString);
	static class FName Conv_StringToName(const class FString& InString);
	static void Conv_StringToRotator(const class FString& InString, struct FRotator* OutConvertedRotator, bool* OutIsValid);
	static void Conv_StringToVector(const class FString& InString, struct FVector* OutConvertedVector, bool* OutIsValid);
	static void Conv_StringToVector2D(const class FString& InString, struct FVector2D* OutConvertedVector2D, bool* OutIsValid);
	static void Conv_StringToVector3f(const class FString& InString, struct FVector3f* OutConvertedVector, bool* OutIsValid);
	static class FString Conv_TransformToString(const struct FTransform& InTrans);
	static class FString Conv_Vector2dToString(const struct FVector2D& InVec);
	static class FString Conv_Vector3fToString(const struct FVector3f& InVec);
	static class FString Conv_VectorToString(const struct FVector& InVec);
	static int32 CullArray(const class FString& SourceString, TArray<class FString>* inArray);
	static bool EndsWith(const class FString& SourceString, const class FString& InSuffix, ESearchCase SearchCase);
	static bool EqualEqual_StriStri(const class FString& A, const class FString& B);
	static bool EqualEqual_StrStr(const class FString& A, const class FString& B);
	static int32 FindSubstring(const class FString& SearchIn, const class FString& Substring, bool bUseCase, bool bSearchFromEnd, int32 StartPosition);
	static TArray<class FString> GetCharacterArrayFromString(const class FString& SourceString);
	static int32 GetCharacterAsNumber(const class FString& SourceString, int32 Index_0);
	static class FString GetSubstring(const class FString& SourceString, int32 StartIndex, int32 Length);
	static bool IsEmpty(const class FString& InString);
	static bool IsNumeric(const class FString& SourceString);
	static class FString JoinStringArray(const TArray<class FString>& SourceArray, const class FString& Separator);
	static class FString Left(const class FString& SourceString, int32 Count);
	static class FString LeftChop(const class FString& SourceString, int32 Count);
	static class FString LeftPad(const class FString& SourceString, int32 ChCount);
	static int32 Len(const class FString& S);
	static bool MatchesWildcard(const class FString& SourceString, const class FString& Wildcard, ESearchCase SearchCase);
	static class FString Mid(const class FString& SourceString, int32 START, int32 Count);
	static bool NotEqual_StriStri(const class FString& A, const class FString& B);
	static bool NotEqual_StrStr(const class FString& A, const class FString& B);
	static TArray<class FString> ParseIntoArray(const class FString& SourceString, const class FString& Delimiter, const bool CullEmptyStrings);
	static class FString Replace(const class FString& SourceString, const class FString& from, const class FString& to, ESearchCase SearchCase);
	static int32 ReplaceInline(class FString& SourceString, const class FString& SearchText, const class FString& ReplacementText, ESearchCase SearchCase);
	static class FString Reverse(const class FString& SourceString);
	static class FString Right(const class FString& SourceString, int32 Count);
	static class FString RightChop(const class FString& SourceString, int32 Count);
	static class FString RightPad(const class FString& SourceString, int32 ChCount);
	static bool Split(const class FString& SourceString, const class FString& InStr, class FString* LeftS, class FString* RightS, ESearchCase SearchCase, ESearchDir SearchDir);
	static bool StartsWith(const class FString& SourceString, const class FString& InPrefix, ESearchCase SearchCase);
	static class FString TimeSecondsToString(float InSeconds);
	static class FString ToLower(const class FString& SourceString);
	static class FString ToUpper(const class FString& SourceString);
	static class FString Trim(const class FString& SourceString);
	static class FString TrimTrailing(const class FString& SourceString);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"KismetStringLibrary">();
	}
	static class UKismetStringLibrary* GetDefaultObj()
	{
		return GetDefaultObjImpl<UKismetStringLibrary>();
	}
};
static_assert(alignof(UKismetStringLibrary) == 0x000008, "Wrong alignment on UKismetStringLibrary");
static_assert(sizeof(UKismetStringLibrary) == 0x000028, "Wrong size on UKismetStringLibrary");

// Class Engine.KismetStringTableLibrary
// 0x0000 (0x0028 - 0x0028)
class UKismetStringTableLibrary final : public UBlueprintFunctionLibrary
{
public:
	static TArray<class FString> GetKeysFromStringTable(const class FName TableId);
	static TArray<class FName> GetMetaDataIdsFromStringTableEntry(const class FName TableId, const class FString& Key);
	static TArray<class FName> GetRegisteredStringTables();
	static class FString GetTableEntryMetaData(const class FName TableId, const class FString& Key, const class FName MetaDataId);
	static class FString GetTableEntrySourceString(const class FName TableId, const class FString& Key);
	static class FString GetTableNamespace(const class FName TableId);
	static bool IsRegisteredTableEntry(const class FName TableId, const class FString& Key);
	static bool IsRegisteredTableId(const class FName TableId);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"KismetStringTableLibrary">();
	}
	static class UKismetStringTableLibrary* GetDefaultObj()
	{
		return GetDefaultObjImpl<UKismetStringTableLibrary>();
	}
};
static_assert(alignof(UKismetStringTableLibrary) == 0x000008, "Wrong alignment on UKismetStringTableLibrary");
static_assert(sizeof(UKismetStringTableLibrary) == 0x000028, "Wrong size on UKismetStringTableLibrary");

// Class Engine.BlueprintPathsLibrary
// 0x0000 (0x0028 - 0x0028)
class UBlueprintPathsLibrary final : public UBlueprintFunctionLibrary
{
public:
	static class FString AutomationDir();
	static class FString AutomationLogDir();
	static class FString AutomationTransientDir();
	static class FString BugItDir();
	static class FString ChangeExtension(const class FString& InPath, const class FString& InNewExtension);
	static class FString CloudDir();
	static bool CollapseRelativeDirectories(const class FString& InPath, class FString* OutPath);
	static class FString Combine(const TArray<class FString>& InPaths);
	static class FString ConvertFromSandboxPath(const class FString& InPath, const class FString& InSandboxName);
	static class FString ConvertRelativePathToFull(const class FString& InPath, const class FString& InBasePath);
	static class FString ConvertToSandboxPath(const class FString& InPath, const class FString& InSandboxName);
	static class FString CreateTempFilename(const class FString& Path, const class FString& Prefix, const class FString& Extension);
	static class FString DiffDir();
	static bool DirectoryExists(const class FString& InPath);
	static class FString EngineConfigDir();
	static class FString EngineContentDir();
	static class FString EngineDir();
	static class FString EngineIntermediateDir();
	static class FString EnginePluginsDir();
	static class FString EngineSavedDir();
	static class FString EngineSourceDir();
	static class FString EngineUserDir();
	static class FString EngineVersionAgnosticUserDir();
	static class FString EnterpriseDir();
	static class FString EnterpriseFeaturePackDir();
	static class FString EnterprisePluginsDir();
	static class FString FeaturePackDir();
	static bool FileExists(const class FString& InPath);
	static class FString GameAgnosticSavedDir();
	static class FString GameDevelopersDir();
	static class FString GameSourceDir();
	static class FString GameUserDeveloperDir();
	static class FString GeneratedConfigDir();
	static class FString GetBaseFilename(const class FString& InPath, bool bRemovePath);
	static class FString GetCleanFilename(const class FString& InPath);
	static const TArray<class FString> GetEditorLocalizationPaths();
	static const TArray<class FString> GetEngineLocalizationPaths();
	static class FString GetExtension(const class FString& InPath, bool bIncludeDot);
	static const TArray<class FString> GetGameLocalizationPaths();
	static class FString GetInvalidFileSystemChars();
	static class FString GetPath(const class FString& InPath);
	static class FString GetProjectFilePath();
	static const TArray<class FString> GetPropertyNameLocalizationPaths();
	static class FString GetRelativePathToRoot();
	static const TArray<class FString> GetRestrictedFolderNames();
	static const TArray<class FString> GetToolTipLocalizationPaths();
	static bool HasProjectPersistentDownloadDir();
	static bool IsDrive(const class FString& InPath);
	static bool IsProjectFilePathSet();
	static bool IsRelative(const class FString& InPath);
	static bool IsRestrictedPath(const class FString& InPath);
	static bool IsSamePath(const class FString& PathA, const class FString& PathB);
	static class FString LaunchDir();
	static bool MakePathRelativeTo(const class FString& InPath, const class FString& InRelativeTo, class FString* OutPath);
	static void MakePlatformFilename(const class FString& InPath, class FString* OutPath);
	static void MakeStandardFilename(const class FString& InPath, class FString* OutPath);
	static class FString MakeValidFileName(const class FString& InString, const class FString& InReplacementChar);
	static void NormalizeDirectoryName(const class FString& InPath, class FString* OutPath);
	static void NormalizeFilename(const class FString& InPath, class FString* OutPath);
	static class FString ProfilingDir();
	static class FString ProjectConfigDir();
	static class FString ProjectContentDir();
	static class FString ProjectDir();
	static class FString ProjectIntermediateDir();
	static class FString ProjectLogDir();
	static class FString ProjectModsDir();
	static class FString ProjectPersistentDownloadDir();
	static class FString ProjectPluginsDir();
	static class FString ProjectSavedDir();
	static class FString ProjectUserDir();
	static void RemoveDuplicateSlashes(const class FString& InPath, class FString* OutPath);
	static class FString RootDir();
	static class FString SandboxesDir();
	static class FString ScreenShotDir();
	static class FString SetExtension(const class FString& InPath, const class FString& InNewExtension);
	static void SetProjectFilePath(const class FString& NewGameProjectFilePath);
	static class FString ShaderWorkingDir();
	static bool ShouldSaveToUserDir();
	static class FString SourceConfigDir();
	static void Split(const class FString& InPath, class FString* PathPart, class FString* FilenamePart, class FString* ExtensionPart);
	static void ValidatePath(const class FString& InPath, bool* bDidSucceed, class FText* OutReason);
	static class FString VideoCaptureDir();

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"BlueprintPathsLibrary">();
	}
	static class UBlueprintPathsLibrary* GetDefaultObj()
	{
		return GetDefaultObjImpl<UBlueprintPathsLibrary>();
	}
};
static_assert(alignof(UBlueprintPathsLibrary) == 0x000008, "Wrong alignment on UBlueprintPathsLibrary");
static_assert(sizeof(UBlueprintPathsLibrary) == 0x000028, "Wrong size on UBlueprintPathsLibrary");

// Class Engine.PlatformGameInstance
// 0x00D0 (0x0290 - 0x01C0)
class UPlatformGameInstance final : public UGameInstance
{
public:
	TMulticastInlineDelegate<void()>              ApplicationWillDeactivateDelegate;                 // 0x01C0(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	TMulticastInlineDelegate<void()>              ApplicationHasReactivatedDelegate;                 // 0x01D0(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	TMulticastInlineDelegate<void()>              ApplicationWillEnterBackgroundDelegate;            // 0x01E0(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	TMulticastInlineDelegate<void()>              ApplicationHasEnteredForegroundDelegate;           // 0x01F0(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	TMulticastInlineDelegate<void()>              ApplicationWillTerminateDelegate;                  // 0x0200(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	TMulticastInlineDelegate<void()>              ApplicationShouldUnloadResourcesDelegate;          // 0x0210(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	TMulticastInlineDelegate<void(const TArray<class FString>& StartupArguments)> ApplicationReceivedStartupArgumentsDelegate; // 0x0220(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	TMulticastInlineDelegate<void(const TArray<uint8>& inArray)> ApplicationRegisteredForRemoteNotificationsDelegate; // 0x0230(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	TMulticastInlineDelegate<void(int32 inInt)>   ApplicationRegisteredForUserNotificationsDelegate; // 0x0240(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	TMulticastInlineDelegate<void(const class FString& InString)> ApplicationFailedToRegisterForRemoteNotificationsDelegate; // 0x0250(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	TMulticastInlineDelegate<void(const class FString& InString, EApplicationState inAppState)> ApplicationReceivedRemoteNotificationDelegate; // 0x0260(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	TMulticastInlineDelegate<void(const class FString& InString, int32 inInt, EApplicationState inAppState)> ApplicationReceivedLocalNotificationDelegate; // 0x0270(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	TMulticastInlineDelegate<void(EScreenOrientation inScreenOrientation)> ApplicationReceivedScreenOrientationChangedNotificationDelegate; // 0x0280(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"PlatformGameInstance">();
	}
	static class UPlatformGameInstance* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPlatformGameInstance>();
	}
};
static_assert(alignof(UPlatformGameInstance) == 0x000008, "Wrong alignment on UPlatformGameInstance");
static_assert(sizeof(UPlatformGameInstance) == 0x000290, "Wrong size on UPlatformGameInstance");
static_assert(offsetof(UPlatformGameInstance, ApplicationWillDeactivateDelegate) == 0x0001C0, "Member 'UPlatformGameInstance::ApplicationWillDeactivateDelegate' has a wrong offset!");
static_assert(offsetof(UPlatformGameInstance, ApplicationHasReactivatedDelegate) == 0x0001D0, "Member 'UPlatformGameInstance::ApplicationHasReactivatedDelegate' has a wrong offset!");
static_assert(offsetof(UPlatformGameInstance, ApplicationWillEnterBackgroundDelegate) == 0x0001E0, "Member 'UPlatformGameInstance::ApplicationWillEnterBackgroundDelegate' has a wrong offset!");
static_assert(offsetof(UPlatformGameInstance, ApplicationHasEnteredForegroundDelegate) == 0x0001F0, "Member 'UPlatformGameInstance::ApplicationHasEnteredForegroundDelegate' has a wrong offset!");
static_assert(offsetof(UPlatformGameInstance, ApplicationWillTerminateDelegate) == 0x000200, "Member 'UPlatformGameInstance::ApplicationWillTerminateDelegate' has a wrong offset!");
static_assert(offsetof(UPlatformGameInstance, ApplicationShouldUnloadResourcesDelegate) == 0x000210, "Member 'UPlatformGameInstance::ApplicationShouldUnloadResourcesDelegate' has a wrong offset!");
static_assert(offsetof(UPlatformGameInstance, ApplicationReceivedStartupArgumentsDelegate) == 0x000220, "Member 'UPlatformGameInstance::ApplicationReceivedStartupArgumentsDelegate' has a wrong offset!");
static_assert(offsetof(UPlatformGameInstance, ApplicationRegisteredForRemoteNotificationsDelegate) == 0x000230, "Member 'UPlatformGameInstance::ApplicationRegisteredForRemoteNotificationsDelegate' has a wrong offset!");
static_assert(offsetof(UPlatformGameInstance, ApplicationRegisteredForUserNotificationsDelegate) == 0x000240, "Member 'UPlatformGameInstance::ApplicationRegisteredForUserNotificationsDelegate' has a wrong offset!");
static_assert(offsetof(UPlatformGameInstance, ApplicationFailedToRegisterForRemoteNotificationsDelegate) == 0x000250, "Member 'UPlatformGameInstance::ApplicationFailedToRegisterForRemoteNotificationsDelegate' has a wrong offset!");
static_assert(offsetof(UPlatformGameInstance, ApplicationReceivedRemoteNotificationDelegate) == 0x000260, "Member 'UPlatformGameInstance::ApplicationReceivedRemoteNotificationDelegate' has a wrong offset!");
static_assert(offsetof(UPlatformGameInstance, ApplicationReceivedLocalNotificationDelegate) == 0x000270, "Member 'UPlatformGameInstance::ApplicationReceivedLocalNotificationDelegate' has a wrong offset!");
static_assert(offsetof(UPlatformGameInstance, ApplicationReceivedScreenOrientationChangedNotificationDelegate) == 0x000280, "Member 'UPlatformGameInstance::ApplicationReceivedScreenOrientationChangedNotificationDelegate' has a wrong offset!");

// Class Engine.BlueprintPlatformLibrary
// 0x0000 (0x0028 - 0x0028)
class UBlueprintPlatformLibrary final : public UBlueprintFunctionLibrary
{
public:
	static void CancelLocalNotification(const class FString& ActivationEvent);
	static void CancelLocalNotificationById(int32 NotificationId);
	static void ClearAllLocalNotifications();
	static EScreenOrientation GetAllowedDeviceOrientation();
	static EScreenOrientation GetDeviceOrientation();
	static void GetLaunchNotification(bool* NotificationLaunchedApp, class FString* ActivationEvent, int32* FireDate);
	static int32 ScheduleLocalNotificationAtTime(const struct FDateTime& FireDateTime, bool LocalTime, const class FText& Title, const class FText& Body, const class FText& ACTION, const class FString& ActivationEvent);
	static int32 ScheduleLocalNotificationBadgeAtTime(const struct FDateTime& FireDateTime, bool LocalTime, const class FString& ActivationEvent);
	static void ScheduleLocalNotificationBadgeFromNow(int32 inSecondsFromNow, const class FString& ActivationEvent);
	static int32 ScheduleLocalNotificationFromNow(int32 inSecondsFromNow, const class FText& Title, const class FText& Body, const class FText& ACTION, const class FString& ActivationEvent);
	static void SetAllowedDeviceOrientation(EScreenOrientation NewAllowedDeviceOrientation);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"BlueprintPlatformLibrary">();
	}
	static class UBlueprintPlatformLibrary* GetDefaultObj()
	{
		return GetDefaultObjImpl<UBlueprintPlatformLibrary>();
	}
};
static_assert(alignof(UBlueprintPlatformLibrary) == 0x000008, "Wrong alignment on UBlueprintPlatformLibrary");
static_assert(sizeof(UBlueprintPlatformLibrary) == 0x000028, "Wrong size on UBlueprintPlatformLibrary");

// Class Engine.ImportanceSamplingLibrary
// 0x0000 (0x0028 - 0x0028)
class UImportanceSamplingLibrary final : public UBlueprintFunctionLibrary
{
public:
	static void BreakImportanceTexture(const struct FImportanceTexture& ImportanceTexture, class UTexture2D** Texture, EImportanceWeight* WeightingFunc);
	static void ImportanceSample(const struct FImportanceTexture& Texture, const struct FVector2D& Rand, int32 Samples, float Intensity, struct FVector2D* SamplePosition, struct FLinearColor* SampleColor, float* SampleIntensity, float* SampleSize);
	static struct FImportanceTexture MakeImportanceTexture(class UTexture2D* Texture, EImportanceWeight WeightingFunc);
	static struct FVector2D NextSobolCell2D(int32 Index_0, int32 NumCells, const struct FVector2D& PreviousValue);
	static struct FVector NextSobolCell3D(int32 Index_0, int32 NumCells, const struct FVector& PreviousValue);
	static float NextSobolFloat(int32 Index_0, int32 Dimension, float PreviousValue);
	static struct FVector2D RandomSobolCell2D(int32 Index_0, int32 NumCells, const struct FVector2D& cell, const struct FVector2D& Seed);
	static struct FVector RandomSobolCell3D(int32 Index_0, int32 NumCells, const struct FVector& cell, const struct FVector& Seed);
	static float RandomSobolFloat(int32 Index_0, int32 Dimension, float Seed);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ImportanceSamplingLibrary">();
	}
	static class UImportanceSamplingLibrary* GetDefaultObj()
	{
		return GetDefaultObjImpl<UImportanceSamplingLibrary>();
	}
};
static_assert(alignof(UImportanceSamplingLibrary) == 0x000008, "Wrong alignment on UImportanceSamplingLibrary");
static_assert(sizeof(UImportanceSamplingLibrary) == 0x000028, "Wrong size on UImportanceSamplingLibrary");

// Class Engine.Layer
// 0x0020 (0x0048 - 0x0028)
class ULayer final : public UObject
{
public:
	class FName                                   LayerName;                                         // 0x0028(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         bIsVisible : 1;                                    // 0x0030(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate))
	uint8                                         Pad_31[0x7];                                       // 0x0031(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<struct FLayerActorStats>               ActorStats;                                        // 0x0038(0x0010)(ZeroConstructor, Transient, NativeAccessSpecifierPrivate)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"Layer">();
	}
	static class ULayer* GetDefaultObj()
	{
		return GetDefaultObjImpl<ULayer>();
	}
};
static_assert(alignof(ULayer) == 0x000008, "Wrong alignment on ULayer");
static_assert(sizeof(ULayer) == 0x000048, "Wrong size on ULayer");
static_assert(offsetof(ULayer, LayerName) == 0x000028, "Member 'ULayer::LayerName' has a wrong offset!");
static_assert(offsetof(ULayer, ActorStats) == 0x000038, "Member 'ULayer::ActorStats' has a wrong offset!");

// Class Engine.ActorContainer
// 0x0050 (0x0078 - 0x0028)
class UActorContainer final : public UObject
{
public:
	TMap<class FName, class AActor*>              Actors;                                            // 0x0028(0x0050)(UObjectWrapper, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ActorContainer">();
	}
	static class UActorContainer* GetDefaultObj()
	{
		return GetDefaultObjImpl<UActorContainer>();
	}
};
static_assert(alignof(UActorContainer) == 0x000008, "Wrong alignment on UActorContainer");
static_assert(sizeof(UActorContainer) == 0x000078, "Wrong size on UActorContainer");
static_assert(offsetof(UActorContainer, Actors) == 0x000028, "Member 'UActorContainer::Actors' has a wrong offset!");

// Class Engine.LevelBounds
// 0x0010 (0x02B0 - 0x02A0)
class ALevelBounds final : public AActor
{
public:
	class UBoxComponent*                          BoxComponent;                                      // 0x02A0(0x0008)(Edit, ExportObject, ZeroConstructor, InstancedReference, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bAutoUpdateBounds;                                 // 0x02A8(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_2A9[0x7];                                      // 0x02A9(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"LevelBounds">();
	}
	static class ALevelBounds* GetDefaultObj()
	{
		return GetDefaultObjImpl<ALevelBounds>();
	}
};
static_assert(alignof(ALevelBounds) == 0x000008, "Wrong alignment on ALevelBounds");
static_assert(sizeof(ALevelBounds) == 0x0002B0, "Wrong size on ALevelBounds");
static_assert(offsetof(ALevelBounds, BoxComponent) == 0x0002A0, "Member 'ALevelBounds::BoxComponent' has a wrong offset!");
static_assert(offsetof(ALevelBounds, bAutoUpdateBounds) == 0x0002A8, "Member 'ALevelBounds::bAutoUpdateBounds' has a wrong offset!");

// Class Engine.LevelInstanceComponent
// 0x0000 (0x02A0 - 0x02A0)
class ULevelInstanceComponent final : public USceneComponent
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"LevelInstanceComponent">();
	}
	static class ULevelInstanceComponent* GetDefaultObj()
	{
		return GetDefaultObjImpl<ULevelInstanceComponent>();
	}
};
static_assert(alignof(ULevelInstanceComponent) == 0x000010, "Wrong alignment on ULevelInstanceComponent");
static_assert(sizeof(ULevelInstanceComponent) == 0x0002A0, "Wrong size on ULevelInstanceComponent");

// Class Engine.LevelStreamingLevelInstanceEditor
// 0x0000 (0x01A0 - 0x01A0)
class ULevelStreamingLevelInstanceEditor final : public ULevelStreamingAlwaysLoaded
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"LevelStreamingLevelInstanceEditor">();
	}
	static class ULevelStreamingLevelInstanceEditor* GetDefaultObj()
	{
		return GetDefaultObjImpl<ULevelStreamingLevelInstanceEditor>();
	}
};
static_assert(alignof(ULevelStreamingLevelInstanceEditor) == 0x000010, "Wrong alignment on ULevelStreamingLevelInstanceEditor");
static_assert(sizeof(ULevelStreamingLevelInstanceEditor) == 0x0001A0, "Wrong size on ULevelStreamingLevelInstanceEditor");

// Class Engine.LevelInstanceEditorObject
// 0x0000 (0x0028 - 0x0028)
class ULevelInstanceEditorObject final : public UObject
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"LevelInstanceEditorObject">();
	}
	static class ULevelInstanceEditorObject* GetDefaultObj()
	{
		return GetDefaultObjImpl<ULevelInstanceEditorObject>();
	}
};
static_assert(alignof(ULevelInstanceEditorObject) == 0x000008, "Wrong alignment on ULevelInstanceEditorObject");
static_assert(sizeof(ULevelInstanceEditorObject) == 0x000028, "Wrong size on ULevelInstanceEditorObject");

// Class Engine.LevelStreamingLevelInstance
// 0x0030 (0x01D0 - 0x01A0)
class ULevelStreamingLevelInstance final : public ULevelStreamingDynamic
{
public:
	uint8                                         Pad_1A0[0x30];                                     // 0x01A0(0x0030)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"LevelStreamingLevelInstance">();
	}
	static class ULevelStreamingLevelInstance* GetDefaultObj()
	{
		return GetDefaultObjImpl<ULevelStreamingLevelInstance>();
	}
};
static_assert(alignof(ULevelStreamingLevelInstance) == 0x000010, "Wrong alignment on ULevelStreamingLevelInstance");
static_assert(sizeof(ULevelStreamingLevelInstance) == 0x0001D0, "Wrong size on ULevelStreamingLevelInstance");

// Class Engine.LevelInstanceSubsystem
// 0x0190 (0x01C0 - 0x0030)
class ULevelInstanceSubsystem final : public UWorldSubsystem
{
public:
	uint8                                         Pad_30[0x190];                                     // 0x0030(0x0190)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"LevelInstanceSubsystem">();
	}
	static class ULevelInstanceSubsystem* GetDefaultObj()
	{
		return GetDefaultObjImpl<ULevelInstanceSubsystem>();
	}
};
static_assert(alignof(ULevelInstanceSubsystem) == 0x000008, "Wrong alignment on ULevelInstanceSubsystem");
static_assert(sizeof(ULevelInstanceSubsystem) == 0x0001C0, "Wrong size on ULevelInstanceSubsystem");

// Class Engine.LevelScriptActor
// 0x0008 (0x02A8 - 0x02A0)
class ALevelScriptActor : public AActor
{
public:
	uint8                                         bInputEnabled : 1;                                 // 0x02A0(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate))
	uint8                                         Pad_2A1[0x7];                                      // 0x02A1(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void LevelReset();
	bool RemoteEvent(class FName EventName);
	void SetCinematicMode(bool bCinematicMode, bool bHidePlayer, bool bAffectsHUD, bool bAffectsMovement, bool bAffectsTurning);
	void WorldOriginLocationChanged(const struct FIntVector& OldOriginLocation, const struct FIntVector& NewOriginLocation);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"LevelScriptActor">();
	}
	static class ALevelScriptActor* GetDefaultObj()
	{
		return GetDefaultObjImpl<ALevelScriptActor>();
	}
};
static_assert(alignof(ALevelScriptActor) == 0x000008, "Wrong alignment on ALevelScriptActor");
static_assert(sizeof(ALevelScriptActor) == 0x0002A8, "Wrong size on ALevelScriptActor");

// Class Engine.LightmappedSurfaceCollection
// 0x0018 (0x0040 - 0x0028)
class ULightmappedSurfaceCollection final : public UObject
{
public:
	class UModel*                                 SourceModel;                                       // 0x0028(0x0008)(Edit, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TArray<int32>                                 Surfaces;                                          // 0x0030(0x0010)(Edit, ZeroConstructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"LightmappedSurfaceCollection">();
	}
	static class ULightmappedSurfaceCollection* GetDefaultObj()
	{
		return GetDefaultObjImpl<ULightmappedSurfaceCollection>();
	}
};
static_assert(alignof(ULightmappedSurfaceCollection) == 0x000008, "Wrong alignment on ULightmappedSurfaceCollection");
static_assert(sizeof(ULightmappedSurfaceCollection) == 0x000040, "Wrong size on ULightmappedSurfaceCollection");
static_assert(offsetof(ULightmappedSurfaceCollection, SourceModel) == 0x000028, "Member 'ULightmappedSurfaceCollection::SourceModel' has a wrong offset!");
static_assert(offsetof(ULightmappedSurfaceCollection, Surfaces) == 0x000030, "Member 'ULightmappedSurfaceCollection::Surfaces' has a wrong offset!");

// Class Engine.LightmassCharacterIndirectDetailVolume
// 0x0000 (0x02D8 - 0x02D8)
class ALightmassCharacterIndirectDetailVolume final : public AVolume
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"LightmassCharacterIndirectDetailVolume">();
	}
	static class ALightmassCharacterIndirectDetailVolume* GetDefaultObj()
	{
		return GetDefaultObjImpl<ALightmassCharacterIndirectDetailVolume>();
	}
};
static_assert(alignof(ALightmassCharacterIndirectDetailVolume) == 0x000008, "Wrong alignment on ALightmassCharacterIndirectDetailVolume");
static_assert(sizeof(ALightmassCharacterIndirectDetailVolume) == 0x0002D8, "Wrong size on ALightmassCharacterIndirectDetailVolume");

// Class Engine.LightmassImportanceVolume
// 0x0000 (0x02D8 - 0x02D8)
class ALightmassImportanceVolume final : public AVolume
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"LightmassImportanceVolume">();
	}
	static class ALightmassImportanceVolume* GetDefaultObj()
	{
		return GetDefaultObjImpl<ALightmassImportanceVolume>();
	}
};
static_assert(alignof(ALightmassImportanceVolume) == 0x000008, "Wrong alignment on ALightmassImportanceVolume");
static_assert(sizeof(ALightmassImportanceVolume) == 0x0002D8, "Wrong size on ALightmassImportanceVolume");

// Class Engine.LightWeightInstanceBlueprintFunctionLibrary
// 0x0000 (0x0028 - 0x0028)
class ULightWeightInstanceBlueprintFunctionLibrary final : public UBlueprintFunctionLibrary
{
public:
	static struct FActorInstanceHandle ConvertActorToLightWeightInstance(class AActor* Actor);
	static struct FActorInstanceHandle CreateNewLightWeightInstance(class UClass* ActorClass, const struct FTransform& Transform, class UDataLayerInstance* Layer, class UWorld* World);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"LightWeightInstanceBlueprintFunctionLibrary">();
	}
	static class ULightWeightInstanceBlueprintFunctionLibrary* GetDefaultObj()
	{
		return GetDefaultObjImpl<ULightWeightInstanceBlueprintFunctionLibrary>();
	}
};
static_assert(alignof(ULightWeightInstanceBlueprintFunctionLibrary) == 0x000008, "Wrong alignment on ULightWeightInstanceBlueprintFunctionLibrary");
static_assert(sizeof(ULightWeightInstanceBlueprintFunctionLibrary) == 0x000028, "Wrong size on ULightWeightInstanceBlueprintFunctionLibrary");

// Class Engine.ActorInstanceHandleInterface
// 0x0020 (0x0048 - 0x0028)
class UActorInstanceHandleInterface final : public UObject
{
public:
	uint8                                         Pad_28[0x20];                                      // 0x0028(0x0020)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ActorInstanceHandleInterface">();
	}
	static class UActorInstanceHandleInterface* GetDefaultObj()
	{
		return GetDefaultObjImpl<UActorInstanceHandleInterface>();
	}
};
static_assert(alignof(UActorInstanceHandleInterface) == 0x000008, "Wrong alignment on UActorInstanceHandleInterface");
static_assert(sizeof(UActorInstanceHandleInterface) == 0x000048, "Wrong size on UActorInstanceHandleInterface");

// Class Engine.LocalPlayer
// 0x0268 (0x02B0 - 0x0048)
class ULocalPlayer : public UPlayer
{
public:
	uint8                                         Pad_48[0x30];                                      // 0x0048(0x0030)(Fixing Size After Last Property [ Dumper-7 ])
	class UGameViewportClient*                    ViewportClient;                                    // 0x0078(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_80[0x38];                                      // 0x0080(0x0038)(Fixing Size After Last Property [ Dumper-7 ])
	EAspectRatioAxisConstraint                    AspectRatioAxisConstraint;                         // 0x00B8(0x0001)(ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_B9[0x7];                                       // 0x00B9(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	TSubclassOf<class APlayerController>          PendingLevelPlayerControllerClass;                 // 0x00C0(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bSentSplitJoin : 1;                                // 0x00C8(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, Transient, EditConst, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_C9[0x17];                                      // 0x00C9(0x0017)(Fixing Size After Last Property [ Dumper-7 ])
	int32                                         ControllerId;                                      // 0x00E0(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_E4[0x1CC];                                     // 0x00E4(0x01CC)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"LocalPlayer">();
	}
	static class ULocalPlayer* GetDefaultObj()
	{
		return GetDefaultObjImpl<ULocalPlayer>();
	}
};
static_assert(alignof(ULocalPlayer) == 0x000008, "Wrong alignment on ULocalPlayer");
static_assert(sizeof(ULocalPlayer) == 0x0002B0, "Wrong size on ULocalPlayer");
static_assert(offsetof(ULocalPlayer, ViewportClient) == 0x000078, "Member 'ULocalPlayer::ViewportClient' has a wrong offset!");
static_assert(offsetof(ULocalPlayer, AspectRatioAxisConstraint) == 0x0000B8, "Member 'ULocalPlayer::AspectRatioAxisConstraint' has a wrong offset!");
static_assert(offsetof(ULocalPlayer, PendingLevelPlayerControllerClass) == 0x0000C0, "Member 'ULocalPlayer::PendingLevelPlayerControllerClass' has a wrong offset!");
static_assert(offsetof(ULocalPlayer, ControllerId) == 0x0000E0, "Member 'ULocalPlayer::ControllerId' has a wrong offset!");

// Class Engine.LocationVolume
// 0x0010 (0x02E8 - 0x02D8)
class ALocationVolume final : public AVolume
{
public:
	uint8                                         Pad_2D8[0x8];                                      // 0x02D8(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	struct FColor                                 DebugColor;                                        // 0x02E0(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bIsRuntime : 1;                                    // 0x02E4(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_2E5[0x3];                                      // 0x02E5(0x0003)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void Load();
	void Unload();

	bool IsLoaded() const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"LocationVolume">();
	}
	static class ALocationVolume* GetDefaultObj()
	{
		return GetDefaultObjImpl<ALocationVolume>();
	}
};
static_assert(alignof(ALocationVolume) == 0x000008, "Wrong alignment on ALocationVolume");
static_assert(sizeof(ALocationVolume) == 0x0002E8, "Wrong size on ALocationVolume");
static_assert(offsetof(ALocationVolume, DebugColor) == 0x0002E0, "Member 'ALocationVolume::DebugColor' has a wrong offset!");

// Class Engine.LODActor
// 0x0088 (0x0328 - 0x02A0)
class ALODActor final : public AActor
{
public:
	class UStaticMeshComponent*                   StaticMeshComponent;                               // 0x02A0(0x0008)(Edit, ExportObject, ZeroConstructor, EditConst, InstancedReference, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	TMap<struct FHLODInstancingKey, class UInstancedStaticMeshComponent*> InstancedStaticMeshComponents; // 0x02A8(0x0050)(ExportObject, Transient, ContainsInstancedReference, UObjectWrapper, NativeAccessSpecifierPrivate)
	class UHLODProxy*                             Proxy;                                             // 0x02F8(0x0008)(Edit, ZeroConstructor, EditConst, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	class FName                                   Key;                                               // 0x0300(0x0008)(Edit, ZeroConstructor, EditConst, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	float                                         LODDrawDistance;                                   // 0x0308(0x0004)(Edit, ZeroConstructor, EditConst, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	int32                                         LODLevel;                                          // 0x030C(0x0004)(Edit, ZeroConstructor, EditConst, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TArray<class AActor*>                         SubActors;                                         // 0x0310(0x0010)(Edit, ZeroConstructor, EditConst, UObjectWrapper, NativeAccessSpecifierPublic)
	uint8                                         CachedNumHLODLevels;                               // 0x0320(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_321[0x7];                                      // 0x0321(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void OnSubActorEndPlay(class AActor* Actor, EEndPlayReason Reason);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"LODActor">();
	}
	static class ALODActor* GetDefaultObj()
	{
		return GetDefaultObjImpl<ALODActor>();
	}
};
static_assert(alignof(ALODActor) == 0x000008, "Wrong alignment on ALODActor");
static_assert(sizeof(ALODActor) == 0x000328, "Wrong size on ALODActor");
static_assert(offsetof(ALODActor, StaticMeshComponent) == 0x0002A0, "Member 'ALODActor::StaticMeshComponent' has a wrong offset!");
static_assert(offsetof(ALODActor, InstancedStaticMeshComponents) == 0x0002A8, "Member 'ALODActor::InstancedStaticMeshComponents' has a wrong offset!");
static_assert(offsetof(ALODActor, Proxy) == 0x0002F8, "Member 'ALODActor::Proxy' has a wrong offset!");
static_assert(offsetof(ALODActor, Key) == 0x000300, "Member 'ALODActor::Key' has a wrong offset!");
static_assert(offsetof(ALODActor, LODDrawDistance) == 0x000308, "Member 'ALODActor::LODDrawDistance' has a wrong offset!");
static_assert(offsetof(ALODActor, LODLevel) == 0x00030C, "Member 'ALODActor::LODLevel' has a wrong offset!");
static_assert(offsetof(ALODActor, SubActors) == 0x000310, "Member 'ALODActor::SubActors' has a wrong offset!");
static_assert(offsetof(ALODActor, CachedNumHLODLevels) == 0x000320, "Member 'ALODActor::CachedNumHLODLevels' has a wrong offset!");

// Class Engine.MaterialEditorOnlyData
// 0x0638 (0x0678 - 0x0040)
class UMaterialEditorOnlyData final : public UMaterialInterfaceEditorOnlyData
{
public:
	struct FColorMaterialInput                    BaseColor;                                         // 0x0040(0x0030)(NoDestructor, NativeAccessSpecifierPublic)
	struct FScalarMaterialInput                   Metallic;                                          // 0x0070(0x0030)(NoDestructor, NativeAccessSpecifierPublic)
	struct FScalarMaterialInput                   Specular;                                          // 0x00A0(0x0030)(NoDestructor, NativeAccessSpecifierPublic)
	struct FScalarMaterialInput                   Roughness;                                         // 0x00D0(0x0030)(NoDestructor, NativeAccessSpecifierPublic)
	struct FScalarMaterialInput                   Anisotropy;                                        // 0x0100(0x0030)(NoDestructor, NativeAccessSpecifierPublic)
	struct FVectorMaterialInput                   Normal;                                            // 0x0130(0x0038)(NoDestructor, NativeAccessSpecifierPublic)
	struct FVectorMaterialInput                   Tangent;                                           // 0x0168(0x0038)(NoDestructor, NativeAccessSpecifierPublic)
	struct FColorMaterialInput                    EmissiveColor;                                     // 0x01A0(0x0030)(NoDestructor, NativeAccessSpecifierPublic)
	struct FScalarMaterialInput                   Opacity;                                           // 0x01D0(0x0030)(NoDestructor, NativeAccessSpecifierPublic)
	struct FScalarMaterialInput                   OpacityMask;                                       // 0x0200(0x0030)(NoDestructor, NativeAccessSpecifierPublic)
	struct FVectorMaterialInput                   WorldPositionOffset;                               // 0x0230(0x0038)(NoDestructor, NativeAccessSpecifierPublic)
	struct FScalarMaterialInput                   displacement;                                      // 0x0268(0x0030)(NoDestructor, NativeAccessSpecifierPublic)
	struct FColorMaterialInput                    SubsurfaceColor;                                   // 0x0298(0x0030)(NoDestructor, NativeAccessSpecifierPublic)
	struct FScalarMaterialInput                   ClearCoat;                                         // 0x02C8(0x0030)(NoDestructor, NativeAccessSpecifierPublic)
	struct FScalarMaterialInput                   ClearCoatRoughness;                                // 0x02F8(0x0030)(NoDestructor, NativeAccessSpecifierPublic)
	struct FScalarMaterialInput                   AmbientOcclusion;                                  // 0x0328(0x0030)(NoDestructor, NativeAccessSpecifierPublic)
	struct FScalarMaterialInput                   Refraction;                                        // 0x0358(0x0030)(NoDestructor, NativeAccessSpecifierPublic)
	struct FVector2MaterialInput                  CustomizedUVs[0x8];                                // 0x0388(0x0038)(NoDestructor, NativeAccessSpecifierPublic)
	struct FMaterialAttributesInput               MaterialAttributes;                                // 0x0548(0x0030)(NoDestructor, NativeAccessSpecifierPublic)
	struct FScalarMaterialInput                   PixelDepthOffset;                                  // 0x0578(0x0030)(NoDestructor, NativeAccessSpecifierPublic)
	struct FShadingModelMaterialInput             ShadingModelFromMaterialExpression;                // 0x05A8(0x0028)(ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_5D0[0x8];                                      // 0x05D0(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	struct FScalarMaterialInput                   SurfaceThickness;                                  // 0x05D8(0x0030)(NoDestructor, NativeAccessSpecifierPublic)
	struct FStrataMaterialInput                   FrontMaterial;                                     // 0x0608(0x0028)(ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_630[0x8];                                      // 0x0630(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	struct FMaterialExpressionCollection          ExpressionCollection;                              // 0x0638(0x0030)(NativeAccessSpecifierPublic)
	TArray<struct FParameterGroupData>            ParameterGroupData;                                // 0x0668(0x0010)(Edit, EditFixedSize, ZeroConstructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialEditorOnlyData">();
	}
	static class UMaterialEditorOnlyData* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialEditorOnlyData>();
	}
};
static_assert(alignof(UMaterialEditorOnlyData) == 0x000008, "Wrong alignment on UMaterialEditorOnlyData");
static_assert(sizeof(UMaterialEditorOnlyData) == 0x000678, "Wrong size on UMaterialEditorOnlyData");
static_assert(offsetof(UMaterialEditorOnlyData, BaseColor) == 0x000040, "Member 'UMaterialEditorOnlyData::BaseColor' has a wrong offset!");
static_assert(offsetof(UMaterialEditorOnlyData, Metallic) == 0x000070, "Member 'UMaterialEditorOnlyData::Metallic' has a wrong offset!");
static_assert(offsetof(UMaterialEditorOnlyData, Specular) == 0x0000A0, "Member 'UMaterialEditorOnlyData::Specular' has a wrong offset!");
static_assert(offsetof(UMaterialEditorOnlyData, Roughness) == 0x0000D0, "Member 'UMaterialEditorOnlyData::Roughness' has a wrong offset!");
static_assert(offsetof(UMaterialEditorOnlyData, Anisotropy) == 0x000100, "Member 'UMaterialEditorOnlyData::Anisotropy' has a wrong offset!");
static_assert(offsetof(UMaterialEditorOnlyData, Normal) == 0x000130, "Member 'UMaterialEditorOnlyData::Normal' has a wrong offset!");
static_assert(offsetof(UMaterialEditorOnlyData, Tangent) == 0x000168, "Member 'UMaterialEditorOnlyData::Tangent' has a wrong offset!");
static_assert(offsetof(UMaterialEditorOnlyData, EmissiveColor) == 0x0001A0, "Member 'UMaterialEditorOnlyData::EmissiveColor' has a wrong offset!");
static_assert(offsetof(UMaterialEditorOnlyData, Opacity) == 0x0001D0, "Member 'UMaterialEditorOnlyData::Opacity' has a wrong offset!");
static_assert(offsetof(UMaterialEditorOnlyData, OpacityMask) == 0x000200, "Member 'UMaterialEditorOnlyData::OpacityMask' has a wrong offset!");
static_assert(offsetof(UMaterialEditorOnlyData, WorldPositionOffset) == 0x000230, "Member 'UMaterialEditorOnlyData::WorldPositionOffset' has a wrong offset!");
static_assert(offsetof(UMaterialEditorOnlyData, displacement) == 0x000268, "Member 'UMaterialEditorOnlyData::displacement' has a wrong offset!");
static_assert(offsetof(UMaterialEditorOnlyData, SubsurfaceColor) == 0x000298, "Member 'UMaterialEditorOnlyData::SubsurfaceColor' has a wrong offset!");
static_assert(offsetof(UMaterialEditorOnlyData, ClearCoat) == 0x0002C8, "Member 'UMaterialEditorOnlyData::ClearCoat' has a wrong offset!");
static_assert(offsetof(UMaterialEditorOnlyData, ClearCoatRoughness) == 0x0002F8, "Member 'UMaterialEditorOnlyData::ClearCoatRoughness' has a wrong offset!");
static_assert(offsetof(UMaterialEditorOnlyData, AmbientOcclusion) == 0x000328, "Member 'UMaterialEditorOnlyData::AmbientOcclusion' has a wrong offset!");
static_assert(offsetof(UMaterialEditorOnlyData, Refraction) == 0x000358, "Member 'UMaterialEditorOnlyData::Refraction' has a wrong offset!");
static_assert(offsetof(UMaterialEditorOnlyData, CustomizedUVs) == 0x000388, "Member 'UMaterialEditorOnlyData::CustomizedUVs' has a wrong offset!");
static_assert(offsetof(UMaterialEditorOnlyData, MaterialAttributes) == 0x000548, "Member 'UMaterialEditorOnlyData::MaterialAttributes' has a wrong offset!");
static_assert(offsetof(UMaterialEditorOnlyData, PixelDepthOffset) == 0x000578, "Member 'UMaterialEditorOnlyData::PixelDepthOffset' has a wrong offset!");
static_assert(offsetof(UMaterialEditorOnlyData, ShadingModelFromMaterialExpression) == 0x0005A8, "Member 'UMaterialEditorOnlyData::ShadingModelFromMaterialExpression' has a wrong offset!");
static_assert(offsetof(UMaterialEditorOnlyData, SurfaceThickness) == 0x0005D8, "Member 'UMaterialEditorOnlyData::SurfaceThickness' has a wrong offset!");
static_assert(offsetof(UMaterialEditorOnlyData, FrontMaterial) == 0x000608, "Member 'UMaterialEditorOnlyData::FrontMaterial' has a wrong offset!");
static_assert(offsetof(UMaterialEditorOnlyData, ExpressionCollection) == 0x000638, "Member 'UMaterialEditorOnlyData::ExpressionCollection' has a wrong offset!");
static_assert(offsetof(UMaterialEditorOnlyData, ParameterGroupData) == 0x000668, "Member 'UMaterialEditorOnlyData::ParameterGroupData' has a wrong offset!");

// Class Engine.MaterialInstanceEditorOnlyData
// 0x00A0 (0x00E0 - 0x0040)
class UMaterialInstanceEditorOnlyData final : public UMaterialInterfaceEditorOnlyData
{
public:
	struct FStaticParameterSetEditorOnlyData      StaticParameters;                                  // 0x0040(0x00A0)(NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialInstanceEditorOnlyData">();
	}
	static class UMaterialInstanceEditorOnlyData* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialInstanceEditorOnlyData>();
	}
};
static_assert(alignof(UMaterialInstanceEditorOnlyData) == 0x000008, "Wrong alignment on UMaterialInstanceEditorOnlyData");
static_assert(sizeof(UMaterialInstanceEditorOnlyData) == 0x0000E0, "Wrong size on UMaterialInstanceEditorOnlyData");
static_assert(offsetof(UMaterialInstanceEditorOnlyData, StaticParameters) == 0x000040, "Member 'UMaterialInstanceEditorOnlyData::StaticParameters' has a wrong offset!");

// Class Engine.MaterialParameterCollection
// 0x0048 (0x0070 - 0x0028)
class UMaterialParameterCollection final : public UObject
{
public:
	struct FGuid                                  StateId;                                           // 0x0028(0x0010)(ZeroConstructor, DuplicateTransient, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TArray<struct FCollectionScalarParameter>     ScalarParameters;                                  // 0x0038(0x0010)(Edit, ZeroConstructor, NativeAccessSpecifierPublic)
	TArray<struct FCollectionVectorParameter>     VectorParameters;                                  // 0x0048(0x0010)(Edit, ZeroConstructor, NativeAccessSpecifierPublic)
	uint8                                         Pad_58[0x18];                                      // 0x0058(0x0018)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	float GetScalarParameterDefaultValue(class FName ParameterName, bool* bParameterFound) const;
	TArray<class FName> GetScalarParameterNames() const;
	struct FLinearColor GetVectorParameterDefaultValue(class FName ParameterName, bool* bParameterFound) const;
	TArray<class FName> GetVectorParameterNames() const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MaterialParameterCollection">();
	}
	static class UMaterialParameterCollection* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMaterialParameterCollection>();
	}
};
static_assert(alignof(UMaterialParameterCollection) == 0x000008, "Wrong alignment on UMaterialParameterCollection");
static_assert(sizeof(UMaterialParameterCollection) == 0x000070, "Wrong size on UMaterialParameterCollection");
static_assert(offsetof(UMaterialParameterCollection, StateId) == 0x000028, "Member 'UMaterialParameterCollection::StateId' has a wrong offset!");
static_assert(offsetof(UMaterialParameterCollection, ScalarParameters) == 0x000038, "Member 'UMaterialParameterCollection::ScalarParameters' has a wrong offset!");
static_assert(offsetof(UMaterialParameterCollection, VectorParameters) == 0x000048, "Member 'UMaterialParameterCollection::VectorParameters' has a wrong offset!");

// Class Engine.MeshMergeCullingVolume
// 0x0000 (0x02D8 - 0x02D8)
class AMeshMergeCullingVolume final : public AVolume
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MeshMergeCullingVolume">();
	}
	static class AMeshMergeCullingVolume* GetDefaultObj()
	{
		return GetDefaultObjImpl<AMeshMergeCullingVolume>();
	}
};
static_assert(alignof(AMeshMergeCullingVolume) == 0x000008, "Wrong alignment on AMeshMergeCullingVolume");
static_assert(sizeof(AMeshMergeCullingVolume) == 0x0002D8, "Wrong size on AMeshMergeCullingVolume");

// Class Engine.MeshSimplificationSettings
// 0x0010 (0x0048 - 0x0038)
class UMeshSimplificationSettings final : public UDeveloperSettings
{
public:
	class FName                                   MeshReductionModuleName;                           // 0x0038(0x0008)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bMeshReductionBackwardCompatible;                  // 0x0040(0x0001)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_41[0x7];                                       // 0x0041(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MeshSimplificationSettings">();
	}
	static class UMeshSimplificationSettings* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMeshSimplificationSettings>();
	}
};
static_assert(alignof(UMeshSimplificationSettings) == 0x000008, "Wrong alignment on UMeshSimplificationSettings");
static_assert(sizeof(UMeshSimplificationSettings) == 0x000048, "Wrong size on UMeshSimplificationSettings");
static_assert(offsetof(UMeshSimplificationSettings, MeshReductionModuleName) == 0x000038, "Member 'UMeshSimplificationSettings::MeshReductionModuleName' has a wrong offset!");
static_assert(offsetof(UMeshSimplificationSettings, bMeshReductionBackwardCompatible) == 0x000040, "Member 'UMeshSimplificationSettings::bMeshReductionBackwardCompatible' has a wrong offset!");

// Class Engine.Model
// 0x0248 (0x0270 - 0x0028)
class UModel final : public UObject
{
public:
	uint8                                         Pad_28[0x248];                                     // 0x0028(0x0248)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"Model">();
	}
	static class UModel* GetDefaultObj()
	{
		return GetDefaultObjImpl<UModel>();
	}
};
static_assert(alignof(UModel) == 0x000008, "Wrong alignment on UModel");
static_assert(sizeof(UModel) == 0x000270, "Wrong size on UModel");

// Class Engine.SimulatedClientNetConnection
// 0x0000 (0x1DF8 - 0x1DF8)
class USimulatedClientNetConnection final : public UNetConnection
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"SimulatedClientNetConnection">();
	}
	static class USimulatedClientNetConnection* GetDefaultObj()
	{
		return GetDefaultObjImpl<USimulatedClientNetConnection>();
	}
};
static_assert(alignof(USimulatedClientNetConnection) == 0x000008, "Wrong alignment on USimulatedClientNetConnection");
static_assert(sizeof(USimulatedClientNetConnection) == 0x001DF8, "Wrong size on USimulatedClientNetConnection");

// Class Engine.BandwidthTestActor
// 0x0020 (0x02C0 - 0x02A0)
class ABandwidthTestActor final : public AActor
{
public:
	struct FBandwidthTestGenerator                BandwidthGenerator;                                // 0x02A0(0x0020)(Net, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"BandwidthTestActor">();
	}
	static class ABandwidthTestActor* GetDefaultObj()
	{
		return GetDefaultObjImpl<ABandwidthTestActor>();
	}
};
static_assert(alignof(ABandwidthTestActor) == 0x000008, "Wrong alignment on ABandwidthTestActor");
static_assert(sizeof(ABandwidthTestActor) == 0x0002C0, "Wrong size on ABandwidthTestActor");
static_assert(offsetof(ABandwidthTestActor, BandwidthGenerator) == 0x0002A0, "Member 'ABandwidthTestActor::BandwidthGenerator' has a wrong offset!");

// Class Engine.DataStreamChannel
// 0x2030 (0x2098 - 0x0068)
class UDataStreamChannel final : public UChannel
{
public:
	uint8                                         Pad_68[0x2030];                                    // 0x0068(0x2030)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"DataStreamChannel">();
	}
	static class UDataStreamChannel* GetDefaultObj()
	{
		return GetDefaultObjImpl<UDataStreamChannel>();
	}
};
static_assert(alignof(UDataStreamChannel) == 0x000008, "Wrong alignment on UDataStreamChannel");
static_assert(sizeof(UDataStreamChannel) == 0x002098, "Wrong size on UDataStreamChannel");

// Class Engine.NetPushModelHelpers
// 0x0000 (0x0028 - 0x0028)
class UNetPushModelHelpers final : public UBlueprintFunctionLibrary
{
public:
	static void MarkPropertyDirty(class UObject* Object, class FName PropertyName);
	static void MarkPropertyDirtyFromRepIndex(class UObject* Object, int32 RepIndex, class FName PropertyName);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"NetPushModelHelpers">();
	}
	static class UNetPushModelHelpers* GetDefaultObj()
	{
		return GetDefaultObjImpl<UNetPushModelHelpers>();
	}
};
static_assert(alignof(UNetPushModelHelpers) == 0x000008, "Wrong alignment on UNetPushModelHelpers");
static_assert(sizeof(UNetPushModelHelpers) == 0x000028, "Wrong size on UNetPushModelHelpers");

// Class Engine.RPCDoSDetectionConfig
// 0x0060 (0x0088 - 0x0028)
class URPCDoSDetectionConfig final : public UObject
{
public:
	bool                                          bRPCDoSDetection;                                  // 0x0028(0x0001)(ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bRPCDoSAnalytics;                                  // 0x0029(0x0001)(ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_2A[0x2];                                       // 0x002A(0x0002)(Fixing Size After Last Property [ Dumper-7 ])
	int32                                         HitchTimeQuotaMS;                                  // 0x002C(0x0004)(ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         HitchSuspendDetectionTimeMS;                       // 0x0030(0x0004)(ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_34[0x4];                                       // 0x0034(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<class FString>                         DetectionSeverity;                                 // 0x0038(0x0010)(ZeroConstructor, Config, NativeAccessSpecifierPublic)
	int32                                         InitialConnectToleranceMS;                         // 0x0048(0x0004)(ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_4C[0x4];                                       // 0x004C(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<class FName>                           RPCBlockWhitelist;                                 // 0x0050(0x0010)(ZeroConstructor, Config, NativeAccessSpecifierPublic)
	TArray<class FName>                           RPCBlockAllowlist;                                 // 0x0060(0x0010)(ZeroConstructor, Config, NativeAccessSpecifierPublic)
	TArray<struct FRPCAnalyticsThreshold>         RPCAnalyticsThresholds;                            // 0x0070(0x0010)(ZeroConstructor, Config, NativeAccessSpecifierPublic)
	double                                        RPCAnalyticsOverrideChance;                        // 0x0080(0x0008)(ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"RPCDoSDetectionConfig">();
	}
	static class URPCDoSDetectionConfig* GetDefaultObj()
	{
		return GetDefaultObjImpl<URPCDoSDetectionConfig>();
	}
};
static_assert(alignof(URPCDoSDetectionConfig) == 0x000008, "Wrong alignment on URPCDoSDetectionConfig");
static_assert(sizeof(URPCDoSDetectionConfig) == 0x000088, "Wrong size on URPCDoSDetectionConfig");
static_assert(offsetof(URPCDoSDetectionConfig, bRPCDoSDetection) == 0x000028, "Member 'URPCDoSDetectionConfig::bRPCDoSDetection' has a wrong offset!");
static_assert(offsetof(URPCDoSDetectionConfig, bRPCDoSAnalytics) == 0x000029, "Member 'URPCDoSDetectionConfig::bRPCDoSAnalytics' has a wrong offset!");
static_assert(offsetof(URPCDoSDetectionConfig, HitchTimeQuotaMS) == 0x00002C, "Member 'URPCDoSDetectionConfig::HitchTimeQuotaMS' has a wrong offset!");
static_assert(offsetof(URPCDoSDetectionConfig, HitchSuspendDetectionTimeMS) == 0x000030, "Member 'URPCDoSDetectionConfig::HitchSuspendDetectionTimeMS' has a wrong offset!");
static_assert(offsetof(URPCDoSDetectionConfig, DetectionSeverity) == 0x000038, "Member 'URPCDoSDetectionConfig::DetectionSeverity' has a wrong offset!");
static_assert(offsetof(URPCDoSDetectionConfig, InitialConnectToleranceMS) == 0x000048, "Member 'URPCDoSDetectionConfig::InitialConnectToleranceMS' has a wrong offset!");
static_assert(offsetof(URPCDoSDetectionConfig, RPCBlockWhitelist) == 0x000050, "Member 'URPCDoSDetectionConfig::RPCBlockWhitelist' has a wrong offset!");
static_assert(offsetof(URPCDoSDetectionConfig, RPCBlockAllowlist) == 0x000060, "Member 'URPCDoSDetectionConfig::RPCBlockAllowlist' has a wrong offset!");
static_assert(offsetof(URPCDoSDetectionConfig, RPCAnalyticsThresholds) == 0x000070, "Member 'URPCDoSDetectionConfig::RPCAnalyticsThresholds' has a wrong offset!");
static_assert(offsetof(URPCDoSDetectionConfig, RPCAnalyticsOverrideChance) == 0x000080, "Member 'URPCDoSDetectionConfig::RPCAnalyticsOverrideChance' has a wrong offset!");

// Class Engine.ObjectLibrary
// 0x0080 (0x00A8 - 0x0028)
class UObjectLibrary final : public UObject
{
public:
	TSubclassOf<class UObject>                    ObjectBaseClass;                                   // 0x0028(0x0008)(Edit, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bHasBlueprintClasses;                              // 0x0030(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_31[0x7];                                       // 0x0031(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<class UObject*>                        Objects;                                           // 0x0038(0x0010)(Edit, ZeroConstructor, Protected, UObjectWrapper, NativeAccessSpecifierProtected)
	TArray<TWeakObjectPtr<class UObject>>         WeakObjects;                                       // 0x0048(0x0010)(ZeroConstructor, Protected, UObjectWrapper, NativeAccessSpecifierProtected)
	bool                                          bUseWeakReferences;                                // 0x0058(0x0001)(ZeroConstructor, Transient, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	bool                                          bIsFullyLoaded;                                    // 0x0059(0x0001)(ZeroConstructor, Transient, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_5A[0x4E];                                      // 0x005A(0x004E)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ObjectLibrary">();
	}
	static class UObjectLibrary* GetDefaultObj()
	{
		return GetDefaultObjImpl<UObjectLibrary>();
	}
};
static_assert(alignof(UObjectLibrary) == 0x000008, "Wrong alignment on UObjectLibrary");
static_assert(sizeof(UObjectLibrary) == 0x0000A8, "Wrong size on UObjectLibrary");
static_assert(offsetof(UObjectLibrary, ObjectBaseClass) == 0x000028, "Member 'UObjectLibrary::ObjectBaseClass' has a wrong offset!");
static_assert(offsetof(UObjectLibrary, bHasBlueprintClasses) == 0x000030, "Member 'UObjectLibrary::bHasBlueprintClasses' has a wrong offset!");
static_assert(offsetof(UObjectLibrary, Objects) == 0x000038, "Member 'UObjectLibrary::Objects' has a wrong offset!");
static_assert(offsetof(UObjectLibrary, WeakObjects) == 0x000048, "Member 'UObjectLibrary::WeakObjects' has a wrong offset!");
static_assert(offsetof(UObjectLibrary, bUseWeakReferences) == 0x000058, "Member 'UObjectLibrary::bUseWeakReferences' has a wrong offset!");
static_assert(offsetof(UObjectLibrary, bIsFullyLoaded) == 0x000059, "Member 'UObjectLibrary::bIsFullyLoaded' has a wrong offset!");

// Class Engine.ObjectReferencer
// 0x0010 (0x0038 - 0x0028)
class UObjectReferencer final : public UObject
{
public:
	TArray<class UObject*>                        ReferencedObjects;                                 // 0x0028(0x0010)(Edit, ZeroConstructor, UObjectWrapper, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ObjectReferencer">();
	}
	static class UObjectReferencer* GetDefaultObj()
	{
		return GetDefaultObjImpl<UObjectReferencer>();
	}
};
static_assert(alignof(UObjectReferencer) == 0x000008, "Wrong alignment on UObjectReferencer");
static_assert(sizeof(UObjectReferencer) == 0x000038, "Wrong size on UObjectReferencer");
static_assert(offsetof(UObjectReferencer, ReferencedObjects) == 0x000028, "Member 'UObjectReferencer::ReferencedObjects' has a wrong offset!");

// Class Engine.OnlineEngineInterface
// 0x0000 (0x0028 - 0x0028)
class UOnlineEngineInterface : public UObject
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"OnlineEngineInterface">();
	}
	static class UOnlineEngineInterface* GetDefaultObj()
	{
		return GetDefaultObjImpl<UOnlineEngineInterface>();
	}
};
static_assert(alignof(UOnlineEngineInterface) == 0x000008, "Wrong alignment on UOnlineEngineInterface");
static_assert(sizeof(UOnlineEngineInterface) == 0x000028, "Wrong size on UOnlineEngineInterface");

// Class Engine.OnlineSession
// 0x0000 (0x0028 - 0x0028)
class UOnlineSession : public UObject
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"OnlineSession">();
	}
	static class UOnlineSession* GetDefaultObj()
	{
		return GetDefaultObjImpl<UOnlineSession>();
	}
};
static_assert(alignof(UOnlineSession) == 0x000008, "Wrong alignment on UOnlineSession");
static_assert(sizeof(UOnlineSession) == 0x000028, "Wrong size on UOnlineSession");

// Class Engine.EngineHandlerComponentFactory
// 0x0000 (0x0028 - 0x0028)
class UEngineHandlerComponentFactory final : public UHandlerComponentFactory
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"EngineHandlerComponentFactory">();
	}
	static class UEngineHandlerComponentFactory* GetDefaultObj()
	{
		return GetDefaultObjImpl<UEngineHandlerComponentFactory>();
	}
};
static_assert(alignof(UEngineHandlerComponentFactory) == 0x000008, "Wrong alignment on UEngineHandlerComponentFactory");
static_assert(sizeof(UEngineHandlerComponentFactory) == 0x000028, "Wrong size on UEngineHandlerComponentFactory");

// Class Engine.PainCausingVolume
// 0x0028 (0x0310 - 0x02E8)
class APainCausingVolume final : public APhysicsVolume
{
public:
	uint8                                         bPainCausing : 1;                                  // 0x02E8(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_2E9[0x3];                                      // 0x02E9(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         DamagePerSec;                                      // 0x02EC(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TSubclassOf<class UDamageType>                DamageType;                                        // 0x02F0(0x0008)(Edit, BlueprintVisible, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         PainInterval;                                      // 0x02F8(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bEntryPain : 1;                                    // 0x02FC(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         BACKUP_bPainCausing : 1;                           // 0x02FC(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_2FD[0x3];                                      // 0x02FD(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	class AController*                            DamageInstigator;                                  // 0x0300(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_308[0x8];                                      // 0x0308(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"PainCausingVolume">();
	}
	static class APainCausingVolume* GetDefaultObj()
	{
		return GetDefaultObjImpl<APainCausingVolume>();
	}
};
static_assert(alignof(APainCausingVolume) == 0x000008, "Wrong alignment on APainCausingVolume");
static_assert(sizeof(APainCausingVolume) == 0x000310, "Wrong size on APainCausingVolume");
static_assert(offsetof(APainCausingVolume, DamagePerSec) == 0x0002EC, "Member 'APainCausingVolume::DamagePerSec' has a wrong offset!");
static_assert(offsetof(APainCausingVolume, DamageType) == 0x0002F0, "Member 'APainCausingVolume::DamageType' has a wrong offset!");
static_assert(offsetof(APainCausingVolume, PainInterval) == 0x0002F8, "Member 'APainCausingVolume::PainInterval' has a wrong offset!");
static_assert(offsetof(APainCausingVolume, DamageInstigator) == 0x000300, "Member 'APainCausingVolume::DamageInstigator' has a wrong offset!");

// Class Engine.ParticleEventManager
// 0x0000 (0x02A0 - 0x02A0)
class AParticleEventManager final : public AActor
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ParticleEventManager">();
	}
	static class AParticleEventManager* GetDefaultObj()
	{
		return GetDefaultObjImpl<AParticleEventManager>();
	}
};
static_assert(alignof(AParticleEventManager) == 0x000008, "Wrong alignment on AParticleEventManager");
static_assert(sizeof(AParticleEventManager) == 0x0002A0, "Wrong size on AParticleEventManager");

// Class Engine.BodySetup
// 0x02C8 (0x0300 - 0x0038)
class UBodySetup : public UBodySetupCore
{
public:
	struct FKAggregateGeom                        AggGeom;                                           // 0x0038(0x0078)(Edit, NativeAccessSpecifierPublic)
	uint8                                         bAlwaysFullAnimWeight : 1;                         // 0x00B0(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Deprecated, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bConsiderForBounds : 1;                            // 0x00B0(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bMeshCollideAll : 1;                               // 0x00B0(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Transient, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bDoubleSidedGeometry : 1;                          // 0x00B0(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bGenerateNonMirroredCollision : 1;                 // 0x00B0(0x0001)(BitIndex: 0x04, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bSharedCookedData : 1;                             // 0x00B0(0x0001)(BitIndex: 0x05, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bGenerateMirroredCollision : 1;                    // 0x00B0(0x0001)(BitIndex: 0x06, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bSupportUVsAndFaceRemap : 1;                       // 0x00B0(0x0001)(BitIndex: 0x07, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         BitPad_B1_0 : 3;                                   // 0x00B1(0x0001)(Fixing Bit-Field Size Between Bits [ Dumper-7 ])
	uint8                                         bNeverNeedsCookedCollisionData : 1;                // 0x00B1(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_B2[0x6];                                       // 0x00B2(0x0006)(Fixing Size After Last Property [ Dumper-7 ])
	class UPhysicalMaterial*                      PhysMaterial;                                      // 0x00B8(0x0008)(Edit, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FWalkableSlopeOverride                 WalkableSlopeOverride;                             // 0x00C0(0x0010)(Edit, IsPlainOldData, NoDestructor, AdvancedDisplay, NativeAccessSpecifierPublic)
	uint8                                         Pad_D0[0x70];                                      // 0x00D0(0x0070)(Fixing Size After Last Property [ Dumper-7 ])
	struct FBodyInstance                          DefaultInstance;                                   // 0x0140(0x0190)(Edit, NativeAccessSpecifierPublic)
	uint8                                         Pad_2D0[0x8];                                      // 0x02D0(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	struct FVector                                BuildScale3D;                                      // 0x02D8(0x0018)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_2F0[0x10];                                     // 0x02F0(0x0010)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"BodySetup">();
	}
	static class UBodySetup* GetDefaultObj()
	{
		return GetDefaultObjImpl<UBodySetup>();
	}
};
static_assert(alignof(UBodySetup) == 0x000008, "Wrong alignment on UBodySetup");
static_assert(sizeof(UBodySetup) == 0x000300, "Wrong size on UBodySetup");
static_assert(offsetof(UBodySetup, AggGeom) == 0x000038, "Member 'UBodySetup::AggGeom' has a wrong offset!");
static_assert(offsetof(UBodySetup, PhysMaterial) == 0x0000B8, "Member 'UBodySetup::PhysMaterial' has a wrong offset!");
static_assert(offsetof(UBodySetup, WalkableSlopeOverride) == 0x0000C0, "Member 'UBodySetup::WalkableSlopeOverride' has a wrong offset!");
static_assert(offsetof(UBodySetup, DefaultInstance) == 0x000140, "Member 'UBodySetup::DefaultInstance' has a wrong offset!");
static_assert(offsetof(UBodySetup, BuildScale3D) == 0x0002D8, "Member 'UBodySetup::BuildScale3D' has a wrong offset!");

// Class Engine.ClusterUnionActor
// 0x0008 (0x02A8 - 0x02A0)
class AClusterUnionActor final : public AActor
{
public:
	class UClusterUnionComponent*                 ClusterUnion;                                      // 0x02A0(0x0008)(Edit, BlueprintVisible, ExportObject, BlueprintReadOnly, ZeroConstructor, InstancedReference, NoDestructor, Protected, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierProtected)

public:
	class UClusterUnionComponent* GetClusterUnionComponent() const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ClusterUnionActor">();
	}
	static class AClusterUnionActor* GetDefaultObj()
	{
		return GetDefaultObjImpl<AClusterUnionActor>();
	}
};
static_assert(alignof(AClusterUnionActor) == 0x000008, "Wrong alignment on AClusterUnionActor");
static_assert(sizeof(AClusterUnionActor) == 0x0002A8, "Wrong size on AClusterUnionActor");
static_assert(offsetof(AClusterUnionActor, ClusterUnion) == 0x0002A0, "Member 'AClusterUnionActor::ClusterUnion' has a wrong offset!");

// Class Engine.ClusterUnionComponent
// 0x0240 (0x07B0 - 0x0570)
class UClusterUnionComponent final : public UPrimitiveComponent
{
public:
	TMulticastInlineDelegate<void(class UPrimitiveComponent* Component, const TSet<int32>& BoneIds, bool bIsNew)> OnComponentAddedEvent; // 0x0570(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	TMulticastInlineDelegate<void(class UPrimitiveComponent* Component)> OnComponentRemovedEvent;    // 0x0580(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	TMulticastInlineDelegate<void(class UClusterUnionComponent* Component, const struct FBoxSphereBounds& Bounds)> OnComponentBoundsChangedEvent; // 0x0590(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	TArray<struct FComponentReference>            ClusteredComponentsReferences;                     // 0x05A0(0x0010)(Edit, ZeroConstructor, NativeAccessSpecifierPrivate)
	uint8                                         Pad_5B0[0x140];                                    // 0x05B0(0x0140)(Fixing Size After Last Property [ Dumper-7 ])
	TMap<int32, struct FClusterUnionParticleCandidateData> UniqueIdxToComponent;                     // 0x06F0(0x0050)(ContainsInstancedReference, NativeAccessSpecifierPrivate)
	struct FClusterUnionReplicatedData            ReplicatedRigidState;                              // 0x0740(0x0002)(Net, RepNotify, NoDestructor, NativeAccessSpecifierPrivate)
	uint8                                         Pad_742[0x6E];                                     // 0x0742(0x006E)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void AddComponentToCluster(class UPrimitiveComponent* InComponent, const TArray<int32>& BoneIds);
	void ForceSetChildToParent(class UPrimitiveComponent* InComponent, const TArray<int32>& BoneIds, const TArray<struct FTransform>& ChildToParent);
	TArray<class AActor*> GetActors();
	TArray<class UPrimitiveComponent*> GetPrimitiveComponents();
	void HandleComponentPhysicsStateChange(class UPrimitiveComponent* ChangedComponent, EComponentPhysicsStateChange StateChange);
	void HandleComponentPhysicsStateChangePostAddIntoClusterUnion(class UPrimitiveComponent* ChangedComponent, EComponentPhysicsStateChange StateChange);
	bool IsComponentAdded(class UPrimitiveComponent* Component);
	void OnRep_RigidState();
	void RemoveComponentFromCluster(class UPrimitiveComponent* InComponent);
	void SetIsAnchored(bool bIsAnchored);

	bool IsAuthority() const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ClusterUnionComponent">();
	}
	static class UClusterUnionComponent* GetDefaultObj()
	{
		return GetDefaultObjImpl<UClusterUnionComponent>();
	}
};
static_assert(alignof(UClusterUnionComponent) == 0x000010, "Wrong alignment on UClusterUnionComponent");
static_assert(sizeof(UClusterUnionComponent) == 0x0007B0, "Wrong size on UClusterUnionComponent");
static_assert(offsetof(UClusterUnionComponent, OnComponentAddedEvent) == 0x000570, "Member 'UClusterUnionComponent::OnComponentAddedEvent' has a wrong offset!");
static_assert(offsetof(UClusterUnionComponent, OnComponentRemovedEvent) == 0x000580, "Member 'UClusterUnionComponent::OnComponentRemovedEvent' has a wrong offset!");
static_assert(offsetof(UClusterUnionComponent, OnComponentBoundsChangedEvent) == 0x000590, "Member 'UClusterUnionComponent::OnComponentBoundsChangedEvent' has a wrong offset!");
static_assert(offsetof(UClusterUnionComponent, ClusteredComponentsReferences) == 0x0005A0, "Member 'UClusterUnionComponent::ClusteredComponentsReferences' has a wrong offset!");
static_assert(offsetof(UClusterUnionComponent, UniqueIdxToComponent) == 0x0006F0, "Member 'UClusterUnionComponent::UniqueIdxToComponent' has a wrong offset!");
static_assert(offsetof(UClusterUnionComponent, ReplicatedRigidState) == 0x000740, "Member 'UClusterUnionComponent::ReplicatedRigidState' has a wrong offset!");

// Class Engine.ConstraintInstanceBlueprintLibrary
// 0x0000 (0x0028 - 0x0028)
class UConstraintInstanceBlueprintLibrary final : public UBlueprintFunctionLibrary
{
public:
	static void CopyParams(struct FConstraintInstanceAccessor& Accessor, struct FConstraintInstanceAccessor& SourceAccessor, bool bKeepPosition, bool bKeepRotation);
	static void GetAngularBreakable(struct FConstraintInstanceAccessor& Accessor, bool* bAngularBreakable, float* AngularBreakThreshold);
	static void GetAngularDriveMode(struct FConstraintInstanceAccessor& Accessor, EAngularDriveMode* OutDriveMode);
	static void GetAngularDriveParams(struct FConstraintInstanceAccessor& Accessor, float* OutPositionStrength, float* OutVelocityStrength, float* OutForceLimit);
	static void GetAngularLimits(struct FConstraintInstanceAccessor& Accessor, EAngularConstraintMotion* Swing1MotionType, float* Swing1LimitAngle, EAngularConstraintMotion* Swing2MotionType, float* Swing2LimitAngle, EAngularConstraintMotion* TwistMotionType, float* TwistLimitAngle);
	static void GetAngularOrientationTarget(struct FConstraintInstanceAccessor& Accessor, struct FRotator* OutPosTarget);
	static void GetAngularPlasticity(struct FConstraintInstanceAccessor& Accessor, bool* bAngularPlasticity, float* AngularPlasticityThreshold);
	static void GetAngularSoftSwingLimitParams(struct FConstraintInstanceAccessor& Accessor, bool* bSoftSwingLimit, float* SwingLimitStiffness, float* SwingLimitDamping, float* SwingLimitRestitution, float* SwingLimitContactDistance);
	static void GetAngularSoftTwistLimitParams(struct FConstraintInstanceAccessor& Accessor, bool* bSoftTwistLimit, float* TwistLimitStiffness, float* TwistLimitDamping, float* TwistLimitRestitution, float* TwistLimitContactDistance);
	static void GetAngularVelocityDriveSLERP(struct FConstraintInstanceAccessor& Accessor, bool* bOutEnableSLERP);
	static void GetAngularVelocityDriveTwistAndSwing(struct FConstraintInstanceAccessor& Accessor, bool* bOutEnableTwistDrive, bool* bOutEnableSwingDrive);
	static void GetAngularVelocityTarget(struct FConstraintInstanceAccessor& Accessor, struct FVector* OutVelTarget);
	static void GetAttachedBodyNames(struct FConstraintInstanceAccessor& Accessor, class FName* ParentBody, class FName* ChildBody);
	static void GetContactTransferScale(struct FConstraintInstanceAccessor& Accessor, float* ContactTransferScale);
	static bool GetDisableCollsion(struct FConstraintInstanceAccessor& Accessor);
	static void GetLinearBreakable(struct FConstraintInstanceAccessor& Accessor, bool* bLinearBreakable, float* LinearBreakThreshold);
	static void GetLinearDriveParams(struct FConstraintInstanceAccessor& Accessor, float* OutPositionStrength, float* OutVelocityStrength, float* OutForceLimit);
	static void GetLinearLimits(struct FConstraintInstanceAccessor& Accessor, ELinearConstraintMotion* XMotion, ELinearConstraintMotion* YMotion, ELinearConstraintMotion* ZMotion, float* Limit);
	static void GetLinearPlasticity(struct FConstraintInstanceAccessor& Accessor, bool* bLinearPlasticity, float* LinearPlasticityThreshold, EConstraintPlasticityType* PlasticityType);
	static void GetLinearPositionDrive(struct FConstraintInstanceAccessor& Accessor, bool* bOutEnableDriveX, bool* bOutEnableDriveY, bool* bOutEnableDriveZ);
	static void GetLinearPositionTarget(struct FConstraintInstanceAccessor& Accessor, struct FVector* OutPosTarget);
	static void GetLinearSoftLimitParams(struct FConstraintInstanceAccessor& Accessor, bool* bSoftLinearLimit, float* LinearLimitStiffness, float* LinearLimitDamping, float* LinearLimitRestitution, float* LinearLimitContactDistance);
	static void GetLinearVelocityDrive(struct FConstraintInstanceAccessor& Accessor, bool* bOutEnableDriveX, bool* bOutEnableDriveY, bool* bOutEnableDriveZ);
	static void GetLinearVelocityTarget(struct FConstraintInstanceAccessor& Accessor, struct FVector* OutVelTarget);
	static bool GetMassConditioningEnabled(struct FConstraintInstanceAccessor& Accessor);
	static void GetOrientationDriveSLERP(struct FConstraintInstanceAccessor& Accessor, bool* bOutEnableSLERP);
	static void GetOrientationDriveTwistAndSwing(struct FConstraintInstanceAccessor& Accessor, bool* bOutEnableTwistDrive, bool* bOutEnableSwingDrive);
	static bool GetParentDominates(struct FConstraintInstanceAccessor& Accessor);
	static void GetProjectionParams(struct FConstraintInstanceAccessor& Accessor, bool* bEnableProjection, float* ProjectionLinearAlpha, float* ProjectionAngularAlpha);
	static void SetAngularBreakable(struct FConstraintInstanceAccessor& Accessor, bool bAngularBreakable, float AngularBreakThreshold);
	static void SetAngularDriveMode(struct FConstraintInstanceAccessor& Accessor, EAngularDriveMode DriveMode);
	static void SetAngularDriveParams(struct FConstraintInstanceAccessor& Accessor, float PositionStrength, float VelocityStrength, float InForceLimit);
	static void SetAngularLimits(struct FConstraintInstanceAccessor& Accessor, EAngularConstraintMotion Swing1MotionType, float Swing1LimitAngle, EAngularConstraintMotion Swing2MotionType, float Swing2LimitAngle, EAngularConstraintMotion TwistMotionType, float TwistLimitAngle);
	static void SetAngularOrientationTarget(struct FConstraintInstanceAccessor& Accessor, const struct FRotator& InPosTarget);
	static void SetAngularPlasticity(struct FConstraintInstanceAccessor& Accessor, bool bAngularPlasticity, float AngularPlasticityThreshold);
	static void SetAngularSoftSwingLimitParams(struct FConstraintInstanceAccessor& Accessor, bool bSoftSwingLimit, float SwingLimitStiffness, float SwingLimitDamping, float SwingLimitRestitution, float SwingLimitContactDistance);
	static void SetAngularSoftTwistLimitParams(struct FConstraintInstanceAccessor& Accessor, bool bSoftTwistLimit, float TwistLimitStiffness, float TwistLimitDamping, float TwistLimitRestitution, float TwistLimitContactDistance);
	static void SetAngularVelocityDriveSLERP(struct FConstraintInstanceAccessor& Accessor, bool bEnableSLERP);
	static void SetAngularVelocityDriveTwistAndSwing(struct FConstraintInstanceAccessor& Accessor, bool bEnableTwistDrive, bool bEnableSwingDrive);
	static void SetAngularVelocityTarget(struct FConstraintInstanceAccessor& Accessor, const struct FVector& InVelTarget);
	static void SetContactTransferScale(struct FConstraintInstanceAccessor& Accessor, float ContactTransferScale);
	static void SetDisableCollision(struct FConstraintInstanceAccessor& Accessor, bool bDisableCollision);
	static void SetLinearBreakable(struct FConstraintInstanceAccessor& Accessor, bool bLinearBreakable, float LinearBreakThreshold);
	static void SetLinearDriveParams(struct FConstraintInstanceAccessor& Accessor, float PositionStrength, float VelocityStrength, float InForceLimit);
	static void SetLinearLimits(struct FConstraintInstanceAccessor& Accessor, ELinearConstraintMotion XMotion, ELinearConstraintMotion YMotion, ELinearConstraintMotion ZMotion, float Limit);
	static void SetLinearPlasticity(struct FConstraintInstanceAccessor& Accessor, bool bLinearPlasticity, float LinearPlasticityThreshold, EConstraintPlasticityType PlasticityType);
	static void SetLinearPositionDrive(struct FConstraintInstanceAccessor& Accessor, bool bEnableDriveX, bool bEnableDriveY, bool bEnableDriveZ);
	static void SetLinearPositionTarget(struct FConstraintInstanceAccessor& Accessor, const struct FVector& InPosTarget);
	static void SetLinearSoftLimitParams(struct FConstraintInstanceAccessor& Accessor, bool bSoftLinearLimit, float LinearLimitStiffness, float LinearLimitDamping, float LinearLimitRestitution, float LinearLimitContactDistance);
	static void SetLinearVelocityDrive(struct FConstraintInstanceAccessor& Accessor, bool bEnableDriveX, bool bEnableDriveY, bool bEnableDriveZ);
	static void SetLinearVelocityTarget(struct FConstraintInstanceAccessor& Accessor, const struct FVector& InVelTarget);
	static void SetMassConditioningEnabled(struct FConstraintInstanceAccessor& Accessor, bool bEnableMassConditioning);
	static void SetOrientationDriveSLERP(struct FConstraintInstanceAccessor& Accessor, bool bEnableSLERP);
	static void SetOrientationDriveTwistAndSwing(struct FConstraintInstanceAccessor& Accessor, bool bEnableTwistDrive, bool bEnableSwingDrive);
	static void SetParentDominates(struct FConstraintInstanceAccessor& Accessor, bool bParentDominates);
	static void SetProjectionParams(struct FConstraintInstanceAccessor& Accessor, bool bEnableProjection, float ProjectionLinearAlpha, float ProjectionAngularAlpha);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ConstraintInstanceBlueprintLibrary">();
	}
	static class UConstraintInstanceBlueprintLibrary* GetDefaultObj()
	{
		return GetDefaultObjImpl<UConstraintInstanceBlueprintLibrary>();
	}
};
static_assert(alignof(UConstraintInstanceBlueprintLibrary) == 0x000008, "Wrong alignment on UConstraintInstanceBlueprintLibrary");
static_assert(sizeof(UConstraintInstanceBlueprintLibrary) == 0x000028, "Wrong size on UConstraintInstanceBlueprintLibrary");

// Class Engine.NetworkPhysicsSystem
// 0x0010 (0x0040 - 0x0030)
class UNetworkPhysicsSystem final : public UWorldSubsystem
{
public:
	uint8                                         Pad_30[0x10];                                      // 0x0030(0x0010)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"NetworkPhysicsSystem">();
	}
	static class UNetworkPhysicsSystem* GetDefaultObj()
	{
		return GetDefaultObjImpl<UNetworkPhysicsSystem>();
	}
};
static_assert(alignof(UNetworkPhysicsSystem) == 0x000008, "Wrong alignment on UNetworkPhysicsSystem");
static_assert(sizeof(UNetworkPhysicsSystem) == 0x000040, "Wrong size on UNetworkPhysicsSystem");

// Class Engine.NetworkPhysicsComponent
// 0x00B0 (0x0158 - 0x00A8)
class UNetworkPhysicsComponent final : public UActorComponent
{
public:
	TArray<uint8>                                 ReplicatedInputs;                                  // 0x00A8(0x0010)(Net, ZeroConstructor, Transient, RepNotify, Protected, NativeAccessSpecifierProtected)
	TArray<uint8>                                 ReplicatedStates;                                  // 0x00B8(0x0010)(Net, ZeroConstructor, Transient, RepNotify, Protected, NativeAccessSpecifierProtected)
	uint8                                         Pad_C8[0x90];                                      // 0x00C8(0x0090)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void OnRep_SetReplicatedInputs();
	void OnRep_SetReplicatedStates();
	void ServerReceiveInputsDatas(const TArray<uint8>& ClientInputs);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"NetworkPhysicsComponent">();
	}
	static class UNetworkPhysicsComponent* GetDefaultObj()
	{
		return GetDefaultObjImpl<UNetworkPhysicsComponent>();
	}
};
static_assert(alignof(UNetworkPhysicsComponent) == 0x000008, "Wrong alignment on UNetworkPhysicsComponent");
static_assert(sizeof(UNetworkPhysicsComponent) == 0x000158, "Wrong size on UNetworkPhysicsComponent");
static_assert(offsetof(UNetworkPhysicsComponent, ReplicatedInputs) == 0x0000A8, "Member 'UNetworkPhysicsComponent::ReplicatedInputs' has a wrong offset!");
static_assert(offsetof(UNetworkPhysicsComponent, ReplicatedStates) == 0x0000B8, "Member 'UNetworkPhysicsComponent::ReplicatedStates' has a wrong offset!");

// Class Engine.PhysicalMaterialMask
// 0x0010 (0x0038 - 0x0028)
class UPhysicalMaterialMask final : public UObject
{
public:
	int32                                         UVChannelIndex;                                    // 0x0028(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	ETextureAddress                               AddressX;                                          // 0x002C(0x0001)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	ETextureAddress                               AddressY;                                          // 0x002D(0x0001)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_2E[0xA];                                       // 0x002E(0x000A)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"PhysicalMaterialMask">();
	}
	static class UPhysicalMaterialMask* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPhysicalMaterialMask>();
	}
};
static_assert(alignof(UPhysicalMaterialMask) == 0x000008, "Wrong alignment on UPhysicalMaterialMask");
static_assert(sizeof(UPhysicalMaterialMask) == 0x000038, "Wrong size on UPhysicalMaterialMask");
static_assert(offsetof(UPhysicalMaterialMask, UVChannelIndex) == 0x000028, "Member 'UPhysicalMaterialMask::UVChannelIndex' has a wrong offset!");
static_assert(offsetof(UPhysicalMaterialMask, AddressX) == 0x00002C, "Member 'UPhysicalMaterialMask::AddressX' has a wrong offset!");
static_assert(offsetof(UPhysicalMaterialMask, AddressY) == 0x00002D, "Member 'UPhysicalMaterialMask::AddressY' has a wrong offset!");

// Class Engine.PhysicsAsset
// 0x0128 (0x0150 - 0x0028)
class UPhysicsAsset final : public UObject
{
public:
	uint8                                         Pad_28[0x8];                                       // 0x0028(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<int32>                                 BoundsBodies;                                      // 0x0030(0x0010)(ZeroConstructor, NativeAccessSpecifierPublic)
	TArray<class USkeletalBodySetup*>             SkeletalBodySetups;                                // 0x0040(0x0010)(ExportObject, ZeroConstructor, ContainsInstancedReference, UObjectWrapper, NativeAccessSpecifierPublic)
	TArray<class UPhysicsConstraintTemplate*>     ConstraintSetup;                                   // 0x0050(0x0010)(ExportObject, ZeroConstructor, ContainsInstancedReference, UObjectWrapper, NativeAccessSpecifierPublic)
	struct FPhysicsAssetSolverSettings            SolverSettings;                                    // 0x0060(0x001C)(Edit, Config, NoDestructor, NativeAccessSpecifierPublic)
	struct FSolverIterations                      SolverIterations;                                  // 0x007C(0x0018)(Edit, Config, EditConst, NoDestructor, NativeAccessSpecifierPublic)
	EPhysicsAssetSolverType                       SolverType;                                        // 0x0094(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bNotForDedicatedServer : 1;                        // 0x0095(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_96[0xA2];                                      // 0x0096(0x00A2)(Fixing Size After Last Property [ Dumper-7 ])
	class UThumbnailInfo*                         ThumbnailInfo;                                     // 0x0138(0x0008)(Edit, ExportObject, ZeroConstructor, EditConst, InstancedReference, NoDestructor, PersistentInstance, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TArray<class UBodySetup*>                     BodySetup;                                         // 0x0140(0x0010)(ExportObject, ZeroConstructor, Deprecated, ContainsInstancedReference, UObjectWrapper, NativeAccessSpecifierPrivate)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"PhysicsAsset">();
	}
	static class UPhysicsAsset* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPhysicsAsset>();
	}
};
static_assert(alignof(UPhysicsAsset) == 0x000008, "Wrong alignment on UPhysicsAsset");
static_assert(sizeof(UPhysicsAsset) == 0x000150, "Wrong size on UPhysicsAsset");
static_assert(offsetof(UPhysicsAsset, BoundsBodies) == 0x000030, "Member 'UPhysicsAsset::BoundsBodies' has a wrong offset!");
static_assert(offsetof(UPhysicsAsset, SkeletalBodySetups) == 0x000040, "Member 'UPhysicsAsset::SkeletalBodySetups' has a wrong offset!");
static_assert(offsetof(UPhysicsAsset, ConstraintSetup) == 0x000050, "Member 'UPhysicsAsset::ConstraintSetup' has a wrong offset!");
static_assert(offsetof(UPhysicsAsset, SolverSettings) == 0x000060, "Member 'UPhysicsAsset::SolverSettings' has a wrong offset!");
static_assert(offsetof(UPhysicsAsset, SolverIterations) == 0x00007C, "Member 'UPhysicsAsset::SolverIterations' has a wrong offset!");
static_assert(offsetof(UPhysicsAsset, SolverType) == 0x000094, "Member 'UPhysicsAsset::SolverType' has a wrong offset!");
static_assert(offsetof(UPhysicsAsset, ThumbnailInfo) == 0x000138, "Member 'UPhysicsAsset::ThumbnailInfo' has a wrong offset!");
static_assert(offsetof(UPhysicsAsset, BodySetup) == 0x000140, "Member 'UPhysicsAsset::BodySetup' has a wrong offset!");

// Class Engine.SkeletalBodySetup
// 0x0018 (0x0318 - 0x0300)
class USkeletalBodySetup final : public UBodySetup
{
public:
	bool                                          bSkipScaleFromAnimation;                           // 0x0300(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_301[0x7];                                      // 0x0301(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<struct FPhysicalAnimationProfile>      PhysicalAnimationData;                             // 0x0308(0x0010)(ZeroConstructor, NativeAccessSpecifierPrivate)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"SkeletalBodySetup">();
	}
	static class USkeletalBodySetup* GetDefaultObj()
	{
		return GetDefaultObjImpl<USkeletalBodySetup>();
	}
};
static_assert(alignof(USkeletalBodySetup) == 0x000008, "Wrong alignment on USkeletalBodySetup");
static_assert(sizeof(USkeletalBodySetup) == 0x000318, "Wrong size on USkeletalBodySetup");
static_assert(offsetof(USkeletalBodySetup, bSkipScaleFromAnimation) == 0x000300, "Member 'USkeletalBodySetup::bSkipScaleFromAnimation' has a wrong offset!");
static_assert(offsetof(USkeletalBodySetup, PhysicalAnimationData) == 0x000308, "Member 'USkeletalBodySetup::PhysicalAnimationData' has a wrong offset!");

// Class Engine.PhysicsConstraintActor
// 0x0020 (0x02C0 - 0x02A0)
class APhysicsConstraintActor final : public ARigidBodyBase
{
public:
	class UPhysicsConstraintComponent*            ConstraintComp;                                    // 0x02A0(0x0008)(Edit, BlueprintVisible, ExportObject, BlueprintReadOnly, ZeroConstructor, EditConst, InstancedReference, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	class AActor*                                 ConstraintActor1;                                  // 0x02A8(0x0008)(ZeroConstructor, Deprecated, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 ConstraintActor2;                                  // 0x02B0(0x0008)(ZeroConstructor, Deprecated, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bDisableCollision : 1;                             // 0x02B8(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Deprecated, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_2B9[0x7];                                      // 0x02B9(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"PhysicsConstraintActor">();
	}
	static class APhysicsConstraintActor* GetDefaultObj()
	{
		return GetDefaultObjImpl<APhysicsConstraintActor>();
	}
};
static_assert(alignof(APhysicsConstraintActor) == 0x000008, "Wrong alignment on APhysicsConstraintActor");
static_assert(sizeof(APhysicsConstraintActor) == 0x0002C0, "Wrong size on APhysicsConstraintActor");
static_assert(offsetof(APhysicsConstraintActor, ConstraintComp) == 0x0002A0, "Member 'APhysicsConstraintActor::ConstraintComp' has a wrong offset!");
static_assert(offsetof(APhysicsConstraintActor, ConstraintActor1) == 0x0002A8, "Member 'APhysicsConstraintActor::ConstraintActor1' has a wrong offset!");
static_assert(offsetof(APhysicsConstraintActor, ConstraintActor2) == 0x0002B0, "Member 'APhysicsConstraintActor::ConstraintActor2' has a wrong offset!");

// Class Engine.PhysicsConstraintComponent
// 0x02D0 (0x0570 - 0x02A0)
class UPhysicsConstraintComponent final : public USceneComponent
{
public:
	class AActor*                                 ConstraintActor1;                                  // 0x02A0(0x0008)(Edit, ZeroConstructor, DisableEditOnTemplate, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FConstrainComponentPropName            ComponentName1;                                    // 0x02A8(0x0008)(Edit, NoDestructor, NativeAccessSpecifierPublic)
	class AActor*                                 ConstraintActor2;                                  // 0x02B0(0x0008)(Edit, ZeroConstructor, DisableEditOnTemplate, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FConstrainComponentPropName            ComponentName2;                                    // 0x02B8(0x0008)(Edit, NoDestructor, NativeAccessSpecifierPublic)
	uint8                                         Pad_2C0[0x10];                                     // 0x02C0(0x0010)(Fixing Size After Last Property [ Dumper-7 ])
	class UPhysicsConstraintTemplate*             ConstraintSetup;                                   // 0x02D0(0x0008)(ExportObject, ZeroConstructor, InstancedReference, Deprecated, NoDestructor, PersistentInstance, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TMulticastInlineDelegate<void(int32 ConstraintIndex)> OnConstraintBroken;                        // 0x02D8(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	TMulticastInlineDelegate<void(int32 ConstraintIndex)> OnPlasticDeformation;                      // 0x02E8(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	struct FConstraintInstance                    ConstraintInstance;                                // 0x02F8(0x0278)(Edit, NativeAccessSpecifierPublic)

public:
	void BreakConstraint();
	void GetConstrainedComponents(class UPrimitiveComponent** OutComponent1, class FName* OutBoneName1, class UPrimitiveComponent** OutComponent2, class FName* OutBoneName2);
	struct FConstraintInstanceAccessor GetConstraint();
	void GetConstraintForce(struct FVector* OutLinearForce, struct FVector* OutAngularForce);
	bool IsBroken();
	void SetAngularBreakable(bool bAngularBreakable, float AngularBreakThreshold);
	void SetAngularDriveMode(EAngularDriveMode DriveMode);
	void SetAngularDriveParams(float PositionStrength, float VelocityStrength, float InForceLimit);
	void SetAngularOrientationDrive(bool bEnableSwingDrive, bool bEnableTwistDrive);
	void SetAngularOrientationTarget(const struct FRotator& InPosTarget);
	void SetAngularPlasticity(bool bAngularPlasticity, float AngularPlasticityThreshold);
	void SetAngularSwing1Limit(EAngularConstraintMotion MotionType, float Swing1LimitAngle);
	void SetAngularSwing2Limit(EAngularConstraintMotion MotionType, float Swing2LimitAngle);
	void SetAngularTwistLimit(EAngularConstraintMotion ConstraintType, float TwistLimitAngle);
	void SetAngularVelocityDrive(bool bEnableSwingDrive, bool bEnableTwistDrive);
	void SetAngularVelocityDriveSLERP(bool bEnableSLERP);
	void SetAngularVelocityDriveTwistAndSwing(bool bEnableTwistDrive, bool bEnableSwingDrive);
	void SetAngularVelocityTarget(const struct FVector& InVelTarget);
	void SetConstrainedComponents(class UPrimitiveComponent* Component1, class FName BoneName1, class UPrimitiveComponent* Component2, class FName BoneName2);
	void SetConstraintReferenceFrame(EConstraintFrame frame, const struct FTransform& RefFrame);
	void SetConstraintReferenceOrientation(EConstraintFrame frame, const struct FVector& PriAxis, const struct FVector& SecAxis);
	void SetConstraintReferencePosition(EConstraintFrame frame, const struct FVector& RefPosition);
	void SetContactTransferScale(float ContactTransferScale);
	void SetDisableCollision(bool bDisableCollision);
	void SetLinearBreakable(bool bLinearBreakable, float LinearBreakThreshold);
	void SetLinearDriveParams(float PositionStrength, float VelocityStrength, float InForceLimit);
	void SetLinearPlasticity(bool bLinearPlasticity, float LinearPlasticityThreshold, EConstraintPlasticityType PlasticityType);
	void SetLinearPositionDrive(bool bEnableDriveX, bool bEnableDriveY, bool bEnableDriveZ);
	void SetLinearPositionTarget(const struct FVector& InPosTarget);
	void SetLinearVelocityDrive(bool bEnableDriveX, bool bEnableDriveY, bool bEnableDriveZ);
	void SetLinearVelocityTarget(const struct FVector& InVelTarget);
	void SetLinearXLimit(ELinearConstraintMotion ConstraintType, float LimitSize);
	void SetLinearYLimit(ELinearConstraintMotion ConstraintType, float LimitSize);
	void SetLinearZLimit(ELinearConstraintMotion ConstraintType, float LimitSize);
	void SetOrientationDriveSLERP(bool bEnableSLERP);
	void SetOrientationDriveTwistAndSwing(bool bEnableTwistDrive, bool bEnableSwingDrive);

	float GetCurrentSwing1() const;
	float GetCurrentSwing2() const;
	float GetCurrentTwist() const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"PhysicsConstraintComponent">();
	}
	static class UPhysicsConstraintComponent* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPhysicsConstraintComponent>();
	}
};
static_assert(alignof(UPhysicsConstraintComponent) == 0x000010, "Wrong alignment on UPhysicsConstraintComponent");
static_assert(sizeof(UPhysicsConstraintComponent) == 0x000570, "Wrong size on UPhysicsConstraintComponent");
static_assert(offsetof(UPhysicsConstraintComponent, ConstraintActor1) == 0x0002A0, "Member 'UPhysicsConstraintComponent::ConstraintActor1' has a wrong offset!");
static_assert(offsetof(UPhysicsConstraintComponent, ComponentName1) == 0x0002A8, "Member 'UPhysicsConstraintComponent::ComponentName1' has a wrong offset!");
static_assert(offsetof(UPhysicsConstraintComponent, ConstraintActor2) == 0x0002B0, "Member 'UPhysicsConstraintComponent::ConstraintActor2' has a wrong offset!");
static_assert(offsetof(UPhysicsConstraintComponent, ComponentName2) == 0x0002B8, "Member 'UPhysicsConstraintComponent::ComponentName2' has a wrong offset!");
static_assert(offsetof(UPhysicsConstraintComponent, ConstraintSetup) == 0x0002D0, "Member 'UPhysicsConstraintComponent::ConstraintSetup' has a wrong offset!");
static_assert(offsetof(UPhysicsConstraintComponent, OnConstraintBroken) == 0x0002D8, "Member 'UPhysicsConstraintComponent::OnConstraintBroken' has a wrong offset!");
static_assert(offsetof(UPhysicsConstraintComponent, OnPlasticDeformation) == 0x0002E8, "Member 'UPhysicsConstraintComponent::OnPlasticDeformation' has a wrong offset!");
static_assert(offsetof(UPhysicsConstraintComponent, ConstraintInstance) == 0x0002F8, "Member 'UPhysicsConstraintComponent::ConstraintInstance' has a wrong offset!");

// Class Engine.PhysicsConstraintTemplate
// 0x03E8 (0x0410 - 0x0028)
class UPhysicsConstraintTemplate final : public UObject
{
public:
	struct FConstraintInstance                    DefaultInstance;                                   // 0x0028(0x0278)(Edit, NativeAccessSpecifierPublic)
	TArray<struct FPhysicsConstraintProfileHandle> ProfileHandles;                                   // 0x02A0(0x0010)(ZeroConstructor, NativeAccessSpecifierPublic)
	struct FConstraintProfileProperties           DefaultProfile;                                    // 0x02B0(0x0160)(Transient, NoDestructor, NativeAccessSpecifierPrivate)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"PhysicsConstraintTemplate">();
	}
	static class UPhysicsConstraintTemplate* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPhysicsConstraintTemplate>();
	}
};
static_assert(alignof(UPhysicsConstraintTemplate) == 0x000008, "Wrong alignment on UPhysicsConstraintTemplate");
static_assert(sizeof(UPhysicsConstraintTemplate) == 0x000410, "Wrong size on UPhysicsConstraintTemplate");
static_assert(offsetof(UPhysicsConstraintTemplate, DefaultInstance) == 0x000028, "Member 'UPhysicsConstraintTemplate::DefaultInstance' has a wrong offset!");
static_assert(offsetof(UPhysicsConstraintTemplate, ProfileHandles) == 0x0002A0, "Member 'UPhysicsConstraintTemplate::ProfileHandles' has a wrong offset!");
static_assert(offsetof(UPhysicsConstraintTemplate, DefaultProfile) == 0x0002B0, "Member 'UPhysicsConstraintTemplate::DefaultProfile' has a wrong offset!");

// Class Engine.PhysicsSettings
// 0x0160 (0x0240 - 0x00E0)
class UPhysicsSettings final : public UPhysicsSettingsCore
{
public:
	struct FPhysicsPredictionSettings             PhysicsPrediction;                                 // 0x00E0(0x000C)(Edit, Config, NoDestructor, NativeAccessSpecifierPublic)
	struct FRigidBodyErrorCorrection              PhysicErrorCorrection;                             // 0x00EC(0x0034)(Edit, Config, NoDestructor, NativeAccessSpecifierPublic)
	ESettingsLockedAxis                           LockedAxis;                                        // 0x0120(0x0001)(ZeroConstructor, Config, Deprecated, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	ESettingsDOF                                  DefaultDegreesOfFreedom;                           // 0x0121(0x0001)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bSuppressFaceRemapTable;                           // 0x0122(0x0001)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bSupportUVFromHitResults;                          // 0x0123(0x0001)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bDisableActiveActors;                              // 0x0124(0x0001)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bDisableKinematicStaticPairs;                      // 0x0125(0x0001)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bDisableKinematicKinematicPairs;                   // 0x0126(0x0001)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bDisableCCD;                                       // 0x0127(0x0001)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         AnimPhysicsMinDeltaTime;                           // 0x0128(0x0004)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bSimulateAnimPhysicsAfterReset;                    // 0x012C(0x0001)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_12D[0x3];                                      // 0x012D(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         MinPhysicsDeltaTime;                               // 0x0130(0x0004)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         MaxPhysicsDeltaTime;                               // 0x0134(0x0004)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bSubstepping;                                      // 0x0138(0x0001)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bSubsteppingAsync;                                 // 0x0139(0x0001)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bTickPhysicsAsync;                                 // 0x013A(0x0001)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_13B[0x1];                                      // 0x013B(0x0001)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         AsyncFixedTimeStepSize;                            // 0x013C(0x0004)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         MaxSubstepDeltaTime;                               // 0x0140(0x0004)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         MaxSubsteps;                                       // 0x0144(0x0004)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         SyncSceneSmoothingFactor;                          // 0x0148(0x0004)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         InitialAverageFrameRate;                           // 0x014C(0x0004)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         PhysXTreeRebuildRate;                              // 0x0150(0x0004)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_154[0x4];                                      // 0x0154(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<struct FPhysicalSurfaceName>           PhysicalSurfaces;                                  // 0x0158(0x0010)(Edit, ZeroConstructor, Config, NativeAccessSpecifierPublic)
	struct FBroadphaseSettings                    DefaultBroadphaseSettings;                         // 0x0168(0x0080)(Edit, Config, NoDestructor, NativeAccessSpecifierPublic)
	float                                         MinDeltaVelocityForHitEvents;                      // 0x01E8(0x0004)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FChaosPhysicsSettings                  ChaosSettings;                                     // 0x01EC(0x0003)(Edit, Config, NoDestructor, NativeAccessSpecifierPublic)
	uint8                                         Pad_1EF[0x1];                                      // 0x01EF(0x0001)(Fixing Size After Last Property [ Dumper-7 ])
	TMap<class FName, class FString>              DebugPMDrawMaterialPaths;                          // 0x01F0(0x0050)(Edit, Config, NativeAccessSpecifierPublic)

public:
	int32 GetPhysicsHistoryCount() const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"PhysicsSettings">();
	}
	static class UPhysicsSettings* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPhysicsSettings>();
	}
};
static_assert(alignof(UPhysicsSettings) == 0x000008, "Wrong alignment on UPhysicsSettings");
static_assert(sizeof(UPhysicsSettings) == 0x000240, "Wrong size on UPhysicsSettings");
static_assert(offsetof(UPhysicsSettings, PhysicsPrediction) == 0x0000E0, "Member 'UPhysicsSettings::PhysicsPrediction' has a wrong offset!");
static_assert(offsetof(UPhysicsSettings, PhysicErrorCorrection) == 0x0000EC, "Member 'UPhysicsSettings::PhysicErrorCorrection' has a wrong offset!");
static_assert(offsetof(UPhysicsSettings, LockedAxis) == 0x000120, "Member 'UPhysicsSettings::LockedAxis' has a wrong offset!");
static_assert(offsetof(UPhysicsSettings, DefaultDegreesOfFreedom) == 0x000121, "Member 'UPhysicsSettings::DefaultDegreesOfFreedom' has a wrong offset!");
static_assert(offsetof(UPhysicsSettings, bSuppressFaceRemapTable) == 0x000122, "Member 'UPhysicsSettings::bSuppressFaceRemapTable' has a wrong offset!");
static_assert(offsetof(UPhysicsSettings, bSupportUVFromHitResults) == 0x000123, "Member 'UPhysicsSettings::bSupportUVFromHitResults' has a wrong offset!");
static_assert(offsetof(UPhysicsSettings, bDisableActiveActors) == 0x000124, "Member 'UPhysicsSettings::bDisableActiveActors' has a wrong offset!");
static_assert(offsetof(UPhysicsSettings, bDisableKinematicStaticPairs) == 0x000125, "Member 'UPhysicsSettings::bDisableKinematicStaticPairs' has a wrong offset!");
static_assert(offsetof(UPhysicsSettings, bDisableKinematicKinematicPairs) == 0x000126, "Member 'UPhysicsSettings::bDisableKinematicKinematicPairs' has a wrong offset!");
static_assert(offsetof(UPhysicsSettings, bDisableCCD) == 0x000127, "Member 'UPhysicsSettings::bDisableCCD' has a wrong offset!");
static_assert(offsetof(UPhysicsSettings, AnimPhysicsMinDeltaTime) == 0x000128, "Member 'UPhysicsSettings::AnimPhysicsMinDeltaTime' has a wrong offset!");
static_assert(offsetof(UPhysicsSettings, bSimulateAnimPhysicsAfterReset) == 0x00012C, "Member 'UPhysicsSettings::bSimulateAnimPhysicsAfterReset' has a wrong offset!");
static_assert(offsetof(UPhysicsSettings, MinPhysicsDeltaTime) == 0x000130, "Member 'UPhysicsSettings::MinPhysicsDeltaTime' has a wrong offset!");
static_assert(offsetof(UPhysicsSettings, MaxPhysicsDeltaTime) == 0x000134, "Member 'UPhysicsSettings::MaxPhysicsDeltaTime' has a wrong offset!");
static_assert(offsetof(UPhysicsSettings, bSubstepping) == 0x000138, "Member 'UPhysicsSettings::bSubstepping' has a wrong offset!");
static_assert(offsetof(UPhysicsSettings, bSubsteppingAsync) == 0x000139, "Member 'UPhysicsSettings::bSubsteppingAsync' has a wrong offset!");
static_assert(offsetof(UPhysicsSettings, bTickPhysicsAsync) == 0x00013A, "Member 'UPhysicsSettings::bTickPhysicsAsync' has a wrong offset!");
static_assert(offsetof(UPhysicsSettings, AsyncFixedTimeStepSize) == 0x00013C, "Member 'UPhysicsSettings::AsyncFixedTimeStepSize' has a wrong offset!");
static_assert(offsetof(UPhysicsSettings, MaxSubstepDeltaTime) == 0x000140, "Member 'UPhysicsSettings::MaxSubstepDeltaTime' has a wrong offset!");
static_assert(offsetof(UPhysicsSettings, MaxSubsteps) == 0x000144, "Member 'UPhysicsSettings::MaxSubsteps' has a wrong offset!");
static_assert(offsetof(UPhysicsSettings, SyncSceneSmoothingFactor) == 0x000148, "Member 'UPhysicsSettings::SyncSceneSmoothingFactor' has a wrong offset!");
static_assert(offsetof(UPhysicsSettings, InitialAverageFrameRate) == 0x00014C, "Member 'UPhysicsSettings::InitialAverageFrameRate' has a wrong offset!");
static_assert(offsetof(UPhysicsSettings, PhysXTreeRebuildRate) == 0x000150, "Member 'UPhysicsSettings::PhysXTreeRebuildRate' has a wrong offset!");
static_assert(offsetof(UPhysicsSettings, PhysicalSurfaces) == 0x000158, "Member 'UPhysicsSettings::PhysicalSurfaces' has a wrong offset!");
static_assert(offsetof(UPhysicsSettings, DefaultBroadphaseSettings) == 0x000168, "Member 'UPhysicsSettings::DefaultBroadphaseSettings' has a wrong offset!");
static_assert(offsetof(UPhysicsSettings, MinDeltaVelocityForHitEvents) == 0x0001E8, "Member 'UPhysicsSettings::MinDeltaVelocityForHitEvents' has a wrong offset!");
static_assert(offsetof(UPhysicsSettings, ChaosSettings) == 0x0001EC, "Member 'UPhysicsSettings::ChaosSettings' has a wrong offset!");
static_assert(offsetof(UPhysicsSettings, DebugPMDrawMaterialPaths) == 0x0001F0, "Member 'UPhysicsSettings::DebugPMDrawMaterialPaths' has a wrong offset!");

// Class Engine.PhysicsThruster
// 0x0008 (0x02A8 - 0x02A0)
class APhysicsThruster final : public ARigidBodyBase
{
public:
	class UPhysicsThrusterComponent*              ThrusterComponent;                                 // 0x02A0(0x0008)(Edit, BlueprintVisible, ExportObject, BlueprintReadOnly, ZeroConstructor, EditConst, InstancedReference, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"PhysicsThruster">();
	}
	static class APhysicsThruster* GetDefaultObj()
	{
		return GetDefaultObjImpl<APhysicsThruster>();
	}
};
static_assert(alignof(APhysicsThruster) == 0x000008, "Wrong alignment on APhysicsThruster");
static_assert(sizeof(APhysicsThruster) == 0x0002A8, "Wrong size on APhysicsThruster");
static_assert(offsetof(APhysicsThruster, ThrusterComponent) == 0x0002A0, "Member 'APhysicsThruster::ThrusterComponent' has a wrong offset!");

// Class Engine.RadialForceComponent
// 0x0030 (0x02D0 - 0x02A0)
class URadialForceComponent final : public USceneComponent
{
public:
	float                                         Radius;                                            // 0x02A0(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	ERadialImpulseFalloff                         Falloff;                                           // 0x02A4(0x0001)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_2A5[0x3];                                      // 0x02A5(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         ImpulseStrength;                                   // 0x02A8(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bImpulseVelChange : 1;                             // 0x02AC(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bIgnoreOwningActor : 1;                            // 0x02AC(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_2AD[0x3];                                      // 0x02AD(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         ForceStrength;                                     // 0x02B0(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         DestructibleDamage;                                // 0x02B4(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TArray<EObjectTypeQuery>                      ObjectTypesToAffect;                               // 0x02B8(0x0010)(Edit, ZeroConstructor, Protected, NativeAccessSpecifierProtected)
	uint8                                         Pad_2C8[0x8];                                      // 0x02C8(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void AddObjectTypeToAffect(EObjectTypeQuery ObjectType);
	void FireImpulse();
	void RemoveObjectTypeToAffect(EObjectTypeQuery ObjectType);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"RadialForceComponent">();
	}
	static class URadialForceComponent* GetDefaultObj()
	{
		return GetDefaultObjImpl<URadialForceComponent>();
	}
};
static_assert(alignof(URadialForceComponent) == 0x000010, "Wrong alignment on URadialForceComponent");
static_assert(sizeof(URadialForceComponent) == 0x0002D0, "Wrong size on URadialForceComponent");
static_assert(offsetof(URadialForceComponent, Radius) == 0x0002A0, "Member 'URadialForceComponent::Radius' has a wrong offset!");
static_assert(offsetof(URadialForceComponent, Falloff) == 0x0002A4, "Member 'URadialForceComponent::Falloff' has a wrong offset!");
static_assert(offsetof(URadialForceComponent, ImpulseStrength) == 0x0002A8, "Member 'URadialForceComponent::ImpulseStrength' has a wrong offset!");
static_assert(offsetof(URadialForceComponent, ForceStrength) == 0x0002B0, "Member 'URadialForceComponent::ForceStrength' has a wrong offset!");
static_assert(offsetof(URadialForceComponent, DestructibleDamage) == 0x0002B4, "Member 'URadialForceComponent::DestructibleDamage' has a wrong offset!");
static_assert(offsetof(URadialForceComponent, ObjectTypesToAffect) == 0x0002B8, "Member 'URadialForceComponent::ObjectTypesToAffect' has a wrong offset!");

// Class Engine.PhysicsFieldStatics
// 0x0000 (0x0028 - 0x0028)
class UPhysicsFieldStatics final : public UBlueprintFunctionLibrary
{
public:
	static int32 EvalPhysicsIntegerField(const class UObject* WorldContextObject, const struct FVector& WorldPosition, const EFieldIntegerType IntegerType);
	static float EvalPhysicsScalarField(const class UObject* WorldContextObject, const struct FVector& WorldPosition, const EFieldScalarType ScalarType);
	static struct FVector EvalPhysicsVectorField(const class UObject* WorldContextObject, const struct FVector& WorldPosition, const EFieldVectorType VectorType);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"PhysicsFieldStatics">();
	}
	static class UPhysicsFieldStatics* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPhysicsFieldStatics>();
	}
};
static_assert(alignof(UPhysicsFieldStatics) == 0x000008, "Wrong alignment on UPhysicsFieldStatics");
static_assert(sizeof(UPhysicsFieldStatics) == 0x000028, "Wrong size on UPhysicsFieldStatics");

// Class Engine.PlayerStart
// 0x0008 (0x02D0 - 0x02C8)
class APlayerStart : public ANavigationObjectBase
{
public:
	class FName                                   PlayerStartTag;                                    // 0x02C8(0x0008)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"PlayerStart">();
	}
	static class APlayerStart* GetDefaultObj()
	{
		return GetDefaultObjImpl<APlayerStart>();
	}
};
static_assert(alignof(APlayerStart) == 0x000008, "Wrong alignment on APlayerStart");
static_assert(sizeof(APlayerStart) == 0x0002D0, "Wrong size on APlayerStart");
static_assert(offsetof(APlayerStart, PlayerStartTag) == 0x0002C8, "Member 'APlayerStart::PlayerStartTag' has a wrong offset!");

// Class Engine.PlayerStartPIE
// 0x0000 (0x02D0 - 0x02D0)
class APlayerStartPIE final : public APlayerStart
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"PlayerStartPIE">();
	}
	static class APlayerStartPIE* GetDefaultObj()
	{
		return GetDefaultObjImpl<APlayerStartPIE>();
	}
};
static_assert(alignof(APlayerStartPIE) == 0x000008, "Wrong alignment on APlayerStartPIE");
static_assert(sizeof(APlayerStartPIE) == 0x0002D0, "Wrong size on APlayerStartPIE");

// Class Engine.PostProcessVolume
// 0x06F8 (0x09D0 - 0x02D8)
class APostProcessVolume final : public AVolume
{
public:
	uint8                                         Pad_2D8[0x8];                                      // 0x02D8(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	struct FPostProcessSettings                   Settings;                                          // 0x02E0(0x06E0)(Edit, BlueprintVisible, Interp, NativeAccessSpecifierPublic)
	float                                         Priority;                                          // 0x09C0(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         BlendRadius;                                       // 0x09C4(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         BlendWeight;                                       // 0x09C8(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, Interp, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bEnabled : 1;                                      // 0x09CC(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bUnbound : 1;                                      // 0x09CC(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_9CD[0x3];                                      // 0x09CD(0x0003)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void AddOrUpdateBlendable(TScriptInterface<class IBlendableInterface> InBlendableObject, float InWeight);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"PostProcessVolume">();
	}
	static class APostProcessVolume* GetDefaultObj()
	{
		return GetDefaultObjImpl<APostProcessVolume>();
	}
};
static_assert(alignof(APostProcessVolume) == 0x000010, "Wrong alignment on APostProcessVolume");
static_assert(sizeof(APostProcessVolume) == 0x0009D0, "Wrong size on APostProcessVolume");
static_assert(offsetof(APostProcessVolume, Settings) == 0x0002E0, "Member 'APostProcessVolume::Settings' has a wrong offset!");
static_assert(offsetof(APostProcessVolume, Priority) == 0x0009C0, "Member 'APostProcessVolume::Priority' has a wrong offset!");
static_assert(offsetof(APostProcessVolume, BlendRadius) == 0x0009C4, "Member 'APostProcessVolume::BlendRadius' has a wrong offset!");
static_assert(offsetof(APostProcessVolume, BlendWeight) == 0x0009C8, "Member 'APostProcessVolume::BlendWeight' has a wrong offset!");

// Class Engine.PrecomputedVisibilityVolume
// 0x0000 (0x02D8 - 0x02D8)
class APrecomputedVisibilityVolume final : public AVolume
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"PrecomputedVisibilityVolume">();
	}
	static class APrecomputedVisibilityVolume* GetDefaultObj()
	{
		return GetDefaultObjImpl<APrecomputedVisibilityVolume>();
	}
};
static_assert(alignof(APrecomputedVisibilityVolume) == 0x000008, "Wrong alignment on APrecomputedVisibilityVolume");
static_assert(sizeof(APrecomputedVisibilityVolume) == 0x0002D8, "Wrong size on APrecomputedVisibilityVolume");

// Class Engine.PrimaryAssetLabel
// 0x0038 (0x0068 - 0x0030)
class UPrimaryAssetLabel final : public UPrimaryDataAsset
{
public:
	struct FPrimaryAssetRules                     Rules;                                             // 0x0030(0x000C)(Edit, NoDestructor, NativeAccessSpecifierPublic)
	uint8                                         bLabelAssetsInMyDirectory : 1;                     // 0x003C(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bIsRuntimeLabel : 1;                               // 0x003C(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bIncludeRedirectors : 1;                           // 0x003C(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_3D[0x3];                                       // 0x003D(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<TSoftObjectPtr<class UObject>>         ExplicitAssets;                                    // 0x0040(0x0010)(Edit, ZeroConstructor, UObjectWrapper, NativeAccessSpecifierPublic)
	TArray<TSoftClassPtr<class UClass>>           ExplicitBlueprints;                                // 0x0050(0x0010)(Edit, ZeroConstructor, UObjectWrapper, NativeAccessSpecifierPublic)
	struct FCollectionReference                   AssetCollection;                                   // 0x0060(0x0008)(Edit, NoDestructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"PrimaryAssetLabel">();
	}
	static class UPrimaryAssetLabel* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPrimaryAssetLabel>();
	}
};
static_assert(alignof(UPrimaryAssetLabel) == 0x000008, "Wrong alignment on UPrimaryAssetLabel");
static_assert(sizeof(UPrimaryAssetLabel) == 0x000068, "Wrong size on UPrimaryAssetLabel");
static_assert(offsetof(UPrimaryAssetLabel, Rules) == 0x000030, "Member 'UPrimaryAssetLabel::Rules' has a wrong offset!");
static_assert(offsetof(UPrimaryAssetLabel, ExplicitAssets) == 0x000040, "Member 'UPrimaryAssetLabel::ExplicitAssets' has a wrong offset!");
static_assert(offsetof(UPrimaryAssetLabel, ExplicitBlueprints) == 0x000050, "Member 'UPrimaryAssetLabel::ExplicitBlueprints' has a wrong offset!");
static_assert(offsetof(UPrimaryAssetLabel, AssetCollection) == 0x000060, "Member 'UPrimaryAssetLabel::AssetCollection' has a wrong offset!");

// Class Engine.LevelStreamingProfilingSubsystem
// 0x0090 (0x00C0 - 0x0030)
class ULevelStreamingProfilingSubsystem final : public UWorldSubsystem
{
public:
	uint8                                         Pad_30[0x90];                                      // 0x0030(0x0090)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"LevelStreamingProfilingSubsystem">();
	}
	static class ULevelStreamingProfilingSubsystem* GetDefaultObj()
	{
		return GetDefaultObjImpl<ULevelStreamingProfilingSubsystem>();
	}
};
static_assert(alignof(ULevelStreamingProfilingSubsystem) == 0x000008, "Wrong alignment on ULevelStreamingProfilingSubsystem");
static_assert(sizeof(ULevelStreamingProfilingSubsystem) == 0x0000C0, "Wrong size on ULevelStreamingProfilingSubsystem");

// Class Engine.ProxyLODMeshSimplificationSettings
// 0x0008 (0x0040 - 0x0038)
class UProxyLODMeshSimplificationSettings final : public UDeveloperSettings
{
public:
	class FName                                   ProxyLODMeshReductionModuleName;                   // 0x0038(0x0008)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ProxyLODMeshSimplificationSettings">();
	}
	static class UProxyLODMeshSimplificationSettings* GetDefaultObj()
	{
		return GetDefaultObjImpl<UProxyLODMeshSimplificationSettings>();
	}
};
static_assert(alignof(UProxyLODMeshSimplificationSettings) == 0x000008, "Wrong alignment on UProxyLODMeshSimplificationSettings");
static_assert(sizeof(UProxyLODMeshSimplificationSettings) == 0x000040, "Wrong size on UProxyLODMeshSimplificationSettings");
static_assert(offsetof(UProxyLODMeshSimplificationSettings, ProxyLODMeshReductionModuleName) == 0x000038, "Member 'UProxyLODMeshSimplificationSettings::ProxyLODMeshReductionModuleName' has a wrong offset!");

// Class Engine.RendererSettings
// 0x01C0 (0x01F8 - 0x0038)
class URendererSettings final : public UDeveloperSettings
{
public:
	EMobileShadingPath                            MobileShadingPath;                                 // 0x0038(0x0001)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_39[0x3];                                       // 0x0039(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	uint8                                         bMobileSupportDeferredOnOpenGL : 1;                // 0x003C(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bMobileSupportGPUScene : 1;                        // 0x003C(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_3D[0x3];                                       // 0x003D(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	EMobileAntiAliasingMethod                     MobileAntiAliasing;                                // 0x0040(0x0001)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EMobileFloatPrecisionMode                     MobileFloatPrecisionMode;                          // 0x0041(0x0001)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_42[0x2];                                       // 0x0042(0x0002)(Fixing Size After Last Property [ Dumper-7 ])
	uint8                                         bMobileAllowDitheredLODTransition : 1;             // 0x0044(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bMobileVirtualTextures : 1;                        // 0x0044(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bDiscardUnusedQualityLevels : 1;                   // 0x0044(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Edit, Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_45[0x3];                                       // 0x0045(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	EShaderCompressionFormat                      ShaderCompressionFormat;                           // 0x0048(0x0001)(ZeroConstructor, Deprecated, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_49[0x3];                                       // 0x0049(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	uint8                                         bOcclusionCulling : 1;                             // 0x004C(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_4D[0x3];                                       // 0x004D(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         MinScreenRadiusForLights;                          // 0x0050(0x0004)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         MinScreenRadiusForEarlyZPass;                      // 0x0054(0x0004)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         MinScreenRadiusForCSMdepth;                        // 0x0058(0x0004)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bPrecomputedVisibilityWarning : 1;                 // 0x005C(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bTextureStreaming : 1;                             // 0x005C(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bUseDXT5NormalMaps : 1;                            // 0x005C(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Edit, Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bVirtualTextures : 1;                              // 0x005C(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (Edit, Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bVirtualTextureEnableAutoImport : 1;               // 0x005C(0x0001)(BitIndex: 0x04, PropSize: 0x0001 (Edit, Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bVirtualTexturedLightmaps : 1;                     // 0x005C(0x0001)(BitIndex: 0x05, PropSize: 0x0001 (Edit, Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bVirtualTextureAnisotropicFiltering : 1;           // 0x005C(0x0001)(BitIndex: 0x06, PropSize: 0x0001 (Edit, Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bEnableVirtualTextureOpacityMask : 1;              // 0x005C(0x0001)(BitIndex: 0x07, PropSize: 0x0001 (Edit, Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_5D[0x3];                                       // 0x005D(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	uint32                                        VirtualTextureTileSize;                            // 0x0060(0x0004)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint32                                        VirtualTextureTileBorderSize;                      // 0x0064(0x0004)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint32                                        VirtualTextureFeedbackFactor;                      // 0x0068(0x0004)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EWorkingColorSpace                            WorkingColorSpaceChoice;                           // 0x006C(0x0001)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_6D[0x3];                                       // 0x006D(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	struct FVector2D                              RedChromaticityCoordinate;                         // 0x0070(0x0010)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector2D                              GreenChromaticityCoordinate;                       // 0x0080(0x0010)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector2D                              BlueChromaticityCoordinate;                        // 0x0090(0x0010)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector2D                              WhiteChromaticityCoordinate;                       // 0x00A0(0x0010)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bClearCoatEnableSecondNormal : 1;                  // 0x00B0(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_B1[0x3];                                       // 0x00B1(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	EDynamicGlobalIlluminationMethod              DynamicGlobalIllumination;                         // 0x00B4(0x0001)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EReflectionMethod                             Reflections;                                       // 0x00B5(0x0001)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_B6[0x2];                                       // 0x00B6(0x0002)(Fixing Size After Last Property [ Dumper-7 ])
	int32                                         ReflectionCaptureResolution;                       // 0x00B8(0x0004)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         ReflectionEnvironmentLightmapMixBasedOnRoughness : 1; // 0x00BC(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bUseHardwareRayTracingForLumen : 1;                // 0x00BC(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_BD[0x3];                                       // 0x00BD(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	ELumenRayLightingMode                         LumenRayLightingMode;                              // 0x00C0(0x0001)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_C1[0x3];                                       // 0x00C1(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	uint8                                         LumenFrontLayerTranslucencyReflections : 1;        // 0x00C4(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_C5[0x3];                                       // 0x00C5(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	ELumenSoftwareTracingMode                     LumenSoftwareTracingMode;                          // 0x00C8(0x0001)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EShadowMapMethod                              ShadowMapMethod;                                   // 0x00C9(0x0001)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_CA[0x2];                                       // 0x00CA(0x0002)(Fixing Size After Last Property [ Dumper-7 ])
	uint8                                         bEnableRayTracing : 1;                             // 0x00CC(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bEnableRayTracingShadows : 1;                      // 0x00CC(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bEnableRayTracingSkylight : 1;                     // 0x00CC(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Deprecated, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bEnableRayTracingTextureLOD : 1;                   // 0x00CC(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (Edit, Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bEnablePathTracing : 1;                            // 0x00CC(0x0001)(BitIndex: 0x04, PropSize: 0x0001 (Edit, Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bGenerateMeshDistanceFields : 1;                   // 0x00CC(0x0001)(BitIndex: 0x05, PropSize: 0x0001 (Edit, Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_CD[0x3];                                       // 0x00CD(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         DistanceFieldVoxelDensity;                         // 0x00D0(0x0004)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bNanite : 1;                                       // 0x00D4(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bAllowStaticLighting : 1;                          // 0x00D4(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bUseNormalMapsForStaticLighting : 1;               // 0x00D4(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Edit, Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bForwardShading : 1;                               // 0x00D4(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (Edit, Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bVertexFoggingForOpaque : 1;                       // 0x00D4(0x0001)(BitIndex: 0x04, PropSize: 0x0001 (Edit, Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bSeparateTranslucency : 1;                         // 0x00D4(0x0001)(BitIndex: 0x05, PropSize: 0x0001 (Edit, Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_D5[0x3];                                       // 0x00D5(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	ETranslucentSortPolicy                        TranslucentSortPolicy;                             // 0x00D8(0x0001)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_D9[0x7];                                       // 0x00D9(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	struct FVector                                TranslucentSortAxis;                               // 0x00E0(0x0018)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EFixedFoveationLevels                         FoveationLevel;                                    // 0x00F8(0x0001)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_F9[0x3];                                       // 0x00F9(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	uint8                                         bDynamicFoveation : 1;                             // 0x00FC(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_FD[0x3];                                       // 0x00FD(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	ECustomDepthStencil                           CustomDepthStencil;                                // 0x0100(0x0001)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_101[0x3];                                      // 0x0101(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	uint8                                         bCustomDepthTaaJitter : 1;                         // 0x0104(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_105[0x3];                                      // 0x0105(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	EAlphaChannelMode                             bEnableAlphaChannelInPostProcessing;               // 0x0108(0x0001)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_109[0x3];                                      // 0x0109(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	uint8                                         bDefaultFeatureBloom : 1;                          // 0x010C(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bDefaultFeatureAmbientOcclusion : 1;               // 0x010C(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bDefaultFeatureAmbientOcclusionStaticFraction : 1; // 0x010C(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Edit, Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bDefaultFeatureAutoExposure : 1;                   // 0x010C(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (Edit, Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_10D[0x3];                                      // 0x010D(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	EAutoExposureMethodUI                         DefaultFeatureAutoExposure;                        // 0x0110(0x0001)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_111[0x3];                                      // 0x0111(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         DefaultFeatureAutoExposureBias;                    // 0x0114(0x0004)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bExtendDefaultLuminanceRangeInAutoExposureSettings : 1; // 0x0118(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_119[0x3];                                      // 0x0119(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         DefaultFeatureLocalExposureHighlightContrastScale; // 0x011C(0x0004)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         DefaultFeatureLocalExposureShadowContrastScale;    // 0x0120(0x0004)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bDefaultFeatureMotionBlur : 1;                     // 0x0124(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bDefaultFeatureLensFlare : 1;                      // 0x0124(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bTemporalUpsampling : 1;                           // 0x0124(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Edit, Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_125[0x3];                                      // 0x0125(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	EAntiAliasingMethod                           DefaultFeatureAntiAliasing;                        // 0x0128(0x0001)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	ECompositingSampleCount                       MSAASampleCount;                                   // 0x0129(0x0001)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	ELightUnits                                   DefaultLightUnits;                                 // 0x012A(0x0001)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EDefaultBackBufferPixelFormat                 DefaultBackBufferPixelFormat;                      // 0x012B(0x0001)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         DefaultManualScreenPercentage;                     // 0x012C(0x0004)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EScreenPercentageMode                         DefaultScreenPercentageDesktopMode;                // 0x0130(0x0004)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EScreenPercentageMode                         DefaultScreenPercentageMobileMode;                 // 0x0134(0x0004)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EScreenPercentageMode                         DefaultScreenPercentageVRMode;                     // 0x0138(0x0004)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EScreenPercentageMode                         DefaultScreenPercentagePathTracerMode;             // 0x013C(0x0004)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bRenderUnbuiltPreviewShadowsInGame : 1;            // 0x0140(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bStencilForLODDither : 1;                          // 0x0140(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_141[0x3];                                      // 0x0141(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	EEarlyZPass                                   EarlyZPass;                                        // 0x0144(0x0001)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_145[0x3];                                      // 0x0145(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	uint8                                         bEarlyZPassOnlyMaterialMasking : 1;                // 0x0148(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bEnableCSMCaching : 1;                             // 0x0148(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bDBuffer : 1;                                      // 0x0148(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Edit, Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_149[0x3];                                      // 0x0149(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	EClearSceneOptions                            ClearSceneMethod;                                  // 0x014C(0x0001)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EVelocityOutputPass                           VelocityPass;                                      // 0x014D(0x0001)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EVertexDeformationOutputsVelocity             VertexDeformationOutputsVelocity;                  // 0x014E(0x0001)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_14F[0x1];                                      // 0x014F(0x0001)(Fixing Size After Last Property [ Dumper-7 ])
	uint8                                         bSelectiveBasePassOutputs : 1;                     // 0x0150(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bDefaultParticleCutouts : 1;                       // 0x0150(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_151[0x3];                                      // 0x0151(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	int32                                         GPUSimulationTextureSizeX;                         // 0x0154(0x0004)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         GPUSimulationTextureSizeY;                         // 0x0158(0x0004)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bGlobalClipPlane : 1;                              // 0x015C(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_15D[0x3];                                      // 0x015D(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	EGBufferFormat                                GBufferFormat;                                     // 0x0160(0x0001)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_161[0x3];                                      // 0x0161(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	uint8                                         bUseGPUMorphTargets : 1;                           // 0x0164(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bNvidiaAftermathEnabled : 1;                       // 0x0164(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bMultiView : 1;                                    // 0x0164(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Edit, Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bMobilePostProcessing : 1;                         // 0x0164(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (Edit, Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bMobileMultiView : 1;                              // 0x0164(0x0001)(BitIndex: 0x04, PropSize: 0x0001 (Edit, Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bMobileUseHWsRGBEncoding : 1;                      // 0x0164(0x0001)(BitIndex: 0x05, PropSize: 0x0001 (Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bRoundRobinOcclusion : 1;                          // 0x0164(0x0001)(BitIndex: 0x06, PropSize: 0x0001 (Edit, Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bMeshStreaming : 1;                                // 0x0164(0x0001)(BitIndex: 0x07, PropSize: 0x0001 (Edit, Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bEnableHeterogeneousVolumes : 1;                   // 0x0165(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_166[0x2];                                      // 0x0166(0x0002)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         WireframeCullThreshold;                            // 0x0168(0x0004)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bSupportStationarySkylight : 1;                    // 0x016C(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bSupportLowQualityLightmaps : 1;                   // 0x016C(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bSupportPointLightWholeSceneShadows : 1;           // 0x016C(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Edit, Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bSupportSkyAtmosphere : 1;                         // 0x016C(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (Edit, Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bSupportSkyAtmosphereAffectsHeightFog : 1;         // 0x016C(0x0001)(BitIndex: 0x04, PropSize: 0x0001 (Edit, Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bSupportCloudShadowOnForwardLitTranslucent : 1;    // 0x016C(0x0001)(BitIndex: 0x05, PropSize: 0x0001 (Edit, Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bSupportTranslucentPerObjectShadow : 1;            // 0x016C(0x0001)(BitIndex: 0x06, PropSize: 0x0001 (Edit, Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bSupportCloudShadowOnSingleLayerWater : 1;         // 0x016C(0x0001)(BitIndex: 0x07, PropSize: 0x0001 (Edit, Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bEnableStrata : 1;                                 // 0x016D(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         StrataOpaqueMaterialRoughRefraction : 1;           // 0x016D(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         StrataDebugAdvancedVisualizationShaders : 1;       // 0x016D(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Edit, Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bMaterialRoughDiffuse : 1;                         // 0x016D(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (Edit, Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bMaterialEnergyConservation : 1;                   // 0x016D(0x0001)(BitIndex: 0x04, PropSize: 0x0001 (Edit, Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bOrderedIndependentTransparencyEnable : 1;         // 0x016D(0x0001)(BitIndex: 0x05, PropSize: 0x0001 (Edit, Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bSupportSkinCacheShaders : 1;                      // 0x016D(0x0001)(BitIndex: 0x06, PropSize: 0x0001 (Edit, Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bSkipCompilingGPUSkinVF : 1;                       // 0x016D(0x0001)(BitIndex: 0x07, PropSize: 0x0001 (Edit, Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_16E[0x2];                                      // 0x016E(0x0002)(Fixing Size After Last Property [ Dumper-7 ])
	ESkinCacheDefaultBehavior                     DefaultSkinCacheBehavior;                          // 0x0170(0x0001)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_171[0x3];                                      // 0x0171(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         SkinCacheSceneMemoryLimitInMB;                     // 0x0174(0x0004)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bMobileEnableStaticAndCSMShadowReceivers : 1;      // 0x0178(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bMobileEnableMovableLightCSMShaderCulling : 1;     // 0x0178(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bMobileForwardEnableLocalLights : 1;               // 0x0178(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Edit, Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bMobileForwardEnableClusteredReflections : 1;      // 0x0178(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (Edit, Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bMobileEnableNoPrecomputedLightingCSMShader : 1;   // 0x0178(0x0001)(BitIndex: 0x04, PropSize: 0x0001 (Edit, Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bMobileAllowDistanceFieldShadows : 1;              // 0x0178(0x0001)(BitIndex: 0x05, PropSize: 0x0001 (Edit, Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bMobileAllowMovableDirectionalLights : 1;          // 0x0178(0x0001)(BitIndex: 0x06, PropSize: 0x0001 (Edit, Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bMobileAllowMovableSpotlightShadows : 1;           // 0x0178(0x0001)(BitIndex: 0x07, PropSize: 0x0001 (Edit, Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bSupport16BitBoneIndex : 1;                        // 0x0179(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bGPUSkinLimit2BoneInfluences : 1;                  // 0x0179(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bSupportDepthOnlyIndexBuffers : 1;                 // 0x0179(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Edit, Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bSupportReversedIndexBuffers : 1;                  // 0x0179(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (Edit, Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bMobileAmbientOcclusion : 1;                       // 0x0179(0x0001)(BitIndex: 0x04, PropSize: 0x0001 (Edit, Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bUseUnlimitedBoneInfluences : 1;                   // 0x0179(0x0001)(BitIndex: 0x05, PropSize: 0x0001 (Edit, Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_17A[0x2];                                      // 0x017A(0x0002)(Fixing Size After Last Property [ Dumper-7 ])
	int32                                         UnlimitedBonInfluencesThreshold;                   // 0x017C(0x0004)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FPerPlatformInt                        DefaultBoneInfluenceLimit;                         // 0x0180(0x0004)(Edit, Config, NoDestructor, NativeAccessSpecifierPublic)
	struct FPerPlatformInt                        MaxSkinBones;                                      // 0x0184(0x0004)(Edit, Config, NoDestructor, NativeAccessSpecifierPublic)
	EMobilePlanarReflectionMode                   MobilePlanarReflectionMode;                        // 0x0188(0x0001)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_189[0x3];                                      // 0x0189(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	uint8                                         bMobileSupportsGen4TAA : 1;                        // 0x018C(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_18D[0x3];                                      // 0x018D(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	struct FPerPlatformBool                       bStreamSkeletalMeshLODs;                           // 0x0190(0x0001)(Edit, Config, NoDestructor, NativeAccessSpecifierPublic)
	struct FPerPlatformBool                       bDiscardSkeletalMeshOptionalLODs;                  // 0x0191(0x0001)(Edit, Config, NoDestructor, NativeAccessSpecifierPublic)
	uint8                                         Pad_192[0x6];                                      // 0x0192(0x0006)(Fixing Size After Last Property [ Dumper-7 ])
	struct FSoftObjectPath                        VisualizeCalibrationColorMaterialPath;             // 0x0198(0x0020)(Edit, ZeroConstructor, Config, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FSoftObjectPath                        VisualizeCalibrationCustomMaterialPath;            // 0x01B8(0x0020)(Edit, ZeroConstructor, Config, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FSoftObjectPath                        VisualizeCalibrationGrayscaleMaterialPath;         // 0x01D8(0x0020)(Edit, ZeroConstructor, Config, HasGetValueTypeHash, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"RendererSettings">();
	}
	static class URendererSettings* GetDefaultObj()
	{
		return GetDefaultObjImpl<URendererSettings>();
	}
};
static_assert(alignof(URendererSettings) == 0x000008, "Wrong alignment on URendererSettings");
static_assert(sizeof(URendererSettings) == 0x0001F8, "Wrong size on URendererSettings");
static_assert(offsetof(URendererSettings, MobileShadingPath) == 0x000038, "Member 'URendererSettings::MobileShadingPath' has a wrong offset!");
static_assert(offsetof(URendererSettings, MobileAntiAliasing) == 0x000040, "Member 'URendererSettings::MobileAntiAliasing' has a wrong offset!");
static_assert(offsetof(URendererSettings, MobileFloatPrecisionMode) == 0x000041, "Member 'URendererSettings::MobileFloatPrecisionMode' has a wrong offset!");
static_assert(offsetof(URendererSettings, ShaderCompressionFormat) == 0x000048, "Member 'URendererSettings::ShaderCompressionFormat' has a wrong offset!");
static_assert(offsetof(URendererSettings, MinScreenRadiusForLights) == 0x000050, "Member 'URendererSettings::MinScreenRadiusForLights' has a wrong offset!");
static_assert(offsetof(URendererSettings, MinScreenRadiusForEarlyZPass) == 0x000054, "Member 'URendererSettings::MinScreenRadiusForEarlyZPass' has a wrong offset!");
static_assert(offsetof(URendererSettings, MinScreenRadiusForCSMdepth) == 0x000058, "Member 'URendererSettings::MinScreenRadiusForCSMdepth' has a wrong offset!");
static_assert(offsetof(URendererSettings, VirtualTextureTileSize) == 0x000060, "Member 'URendererSettings::VirtualTextureTileSize' has a wrong offset!");
static_assert(offsetof(URendererSettings, VirtualTextureTileBorderSize) == 0x000064, "Member 'URendererSettings::VirtualTextureTileBorderSize' has a wrong offset!");
static_assert(offsetof(URendererSettings, VirtualTextureFeedbackFactor) == 0x000068, "Member 'URendererSettings::VirtualTextureFeedbackFactor' has a wrong offset!");
static_assert(offsetof(URendererSettings, WorkingColorSpaceChoice) == 0x00006C, "Member 'URendererSettings::WorkingColorSpaceChoice' has a wrong offset!");
static_assert(offsetof(URendererSettings, RedChromaticityCoordinate) == 0x000070, "Member 'URendererSettings::RedChromaticityCoordinate' has a wrong offset!");
static_assert(offsetof(URendererSettings, GreenChromaticityCoordinate) == 0x000080, "Member 'URendererSettings::GreenChromaticityCoordinate' has a wrong offset!");
static_assert(offsetof(URendererSettings, BlueChromaticityCoordinate) == 0x000090, "Member 'URendererSettings::BlueChromaticityCoordinate' has a wrong offset!");
static_assert(offsetof(URendererSettings, WhiteChromaticityCoordinate) == 0x0000A0, "Member 'URendererSettings::WhiteChromaticityCoordinate' has a wrong offset!");
static_assert(offsetof(URendererSettings, DynamicGlobalIllumination) == 0x0000B4, "Member 'URendererSettings::DynamicGlobalIllumination' has a wrong offset!");
static_assert(offsetof(URendererSettings, Reflections) == 0x0000B5, "Member 'URendererSettings::Reflections' has a wrong offset!");
static_assert(offsetof(URendererSettings, ReflectionCaptureResolution) == 0x0000B8, "Member 'URendererSettings::ReflectionCaptureResolution' has a wrong offset!");
static_assert(offsetof(URendererSettings, LumenRayLightingMode) == 0x0000C0, "Member 'URendererSettings::LumenRayLightingMode' has a wrong offset!");
static_assert(offsetof(URendererSettings, LumenSoftwareTracingMode) == 0x0000C8, "Member 'URendererSettings::LumenSoftwareTracingMode' has a wrong offset!");
static_assert(offsetof(URendererSettings, ShadowMapMethod) == 0x0000C9, "Member 'URendererSettings::ShadowMapMethod' has a wrong offset!");
static_assert(offsetof(URendererSettings, DistanceFieldVoxelDensity) == 0x0000D0, "Member 'URendererSettings::DistanceFieldVoxelDensity' has a wrong offset!");
static_assert(offsetof(URendererSettings, TranslucentSortPolicy) == 0x0000D8, "Member 'URendererSettings::TranslucentSortPolicy' has a wrong offset!");
static_assert(offsetof(URendererSettings, TranslucentSortAxis) == 0x0000E0, "Member 'URendererSettings::TranslucentSortAxis' has a wrong offset!");
static_assert(offsetof(URendererSettings, FoveationLevel) == 0x0000F8, "Member 'URendererSettings::FoveationLevel' has a wrong offset!");
static_assert(offsetof(URendererSettings, CustomDepthStencil) == 0x000100, "Member 'URendererSettings::CustomDepthStencil' has a wrong offset!");
static_assert(offsetof(URendererSettings, bEnableAlphaChannelInPostProcessing) == 0x000108, "Member 'URendererSettings::bEnableAlphaChannelInPostProcessing' has a wrong offset!");
static_assert(offsetof(URendererSettings, DefaultFeatureAutoExposure) == 0x000110, "Member 'URendererSettings::DefaultFeatureAutoExposure' has a wrong offset!");
static_assert(offsetof(URendererSettings, DefaultFeatureAutoExposureBias) == 0x000114, "Member 'URendererSettings::DefaultFeatureAutoExposureBias' has a wrong offset!");
static_assert(offsetof(URendererSettings, DefaultFeatureLocalExposureHighlightContrastScale) == 0x00011C, "Member 'URendererSettings::DefaultFeatureLocalExposureHighlightContrastScale' has a wrong offset!");
static_assert(offsetof(URendererSettings, DefaultFeatureLocalExposureShadowContrastScale) == 0x000120, "Member 'URendererSettings::DefaultFeatureLocalExposureShadowContrastScale' has a wrong offset!");
static_assert(offsetof(URendererSettings, DefaultFeatureAntiAliasing) == 0x000128, "Member 'URendererSettings::DefaultFeatureAntiAliasing' has a wrong offset!");
static_assert(offsetof(URendererSettings, MSAASampleCount) == 0x000129, "Member 'URendererSettings::MSAASampleCount' has a wrong offset!");
static_assert(offsetof(URendererSettings, DefaultLightUnits) == 0x00012A, "Member 'URendererSettings::DefaultLightUnits' has a wrong offset!");
static_assert(offsetof(URendererSettings, DefaultBackBufferPixelFormat) == 0x00012B, "Member 'URendererSettings::DefaultBackBufferPixelFormat' has a wrong offset!");
static_assert(offsetof(URendererSettings, DefaultManualScreenPercentage) == 0x00012C, "Member 'URendererSettings::DefaultManualScreenPercentage' has a wrong offset!");
static_assert(offsetof(URendererSettings, DefaultScreenPercentageDesktopMode) == 0x000130, "Member 'URendererSettings::DefaultScreenPercentageDesktopMode' has a wrong offset!");
static_assert(offsetof(URendererSettings, DefaultScreenPercentageMobileMode) == 0x000134, "Member 'URendererSettings::DefaultScreenPercentageMobileMode' has a wrong offset!");
static_assert(offsetof(URendererSettings, DefaultScreenPercentageVRMode) == 0x000138, "Member 'URendererSettings::DefaultScreenPercentageVRMode' has a wrong offset!");
static_assert(offsetof(URendererSettings, DefaultScreenPercentagePathTracerMode) == 0x00013C, "Member 'URendererSettings::DefaultScreenPercentagePathTracerMode' has a wrong offset!");
static_assert(offsetof(URendererSettings, EarlyZPass) == 0x000144, "Member 'URendererSettings::EarlyZPass' has a wrong offset!");
static_assert(offsetof(URendererSettings, ClearSceneMethod) == 0x00014C, "Member 'URendererSettings::ClearSceneMethod' has a wrong offset!");
static_assert(offsetof(URendererSettings, VelocityPass) == 0x00014D, "Member 'URendererSettings::VelocityPass' has a wrong offset!");
static_assert(offsetof(URendererSettings, VertexDeformationOutputsVelocity) == 0x00014E, "Member 'URendererSettings::VertexDeformationOutputsVelocity' has a wrong offset!");
static_assert(offsetof(URendererSettings, GPUSimulationTextureSizeX) == 0x000154, "Member 'URendererSettings::GPUSimulationTextureSizeX' has a wrong offset!");
static_assert(offsetof(URendererSettings, GPUSimulationTextureSizeY) == 0x000158, "Member 'URendererSettings::GPUSimulationTextureSizeY' has a wrong offset!");
static_assert(offsetof(URendererSettings, GBufferFormat) == 0x000160, "Member 'URendererSettings::GBufferFormat' has a wrong offset!");
static_assert(offsetof(URendererSettings, WireframeCullThreshold) == 0x000168, "Member 'URendererSettings::WireframeCullThreshold' has a wrong offset!");
static_assert(offsetof(URendererSettings, DefaultSkinCacheBehavior) == 0x000170, "Member 'URendererSettings::DefaultSkinCacheBehavior' has a wrong offset!");
static_assert(offsetof(URendererSettings, SkinCacheSceneMemoryLimitInMB) == 0x000174, "Member 'URendererSettings::SkinCacheSceneMemoryLimitInMB' has a wrong offset!");
static_assert(offsetof(URendererSettings, UnlimitedBonInfluencesThreshold) == 0x00017C, "Member 'URendererSettings::UnlimitedBonInfluencesThreshold' has a wrong offset!");
static_assert(offsetof(URendererSettings, DefaultBoneInfluenceLimit) == 0x000180, "Member 'URendererSettings::DefaultBoneInfluenceLimit' has a wrong offset!");
static_assert(offsetof(URendererSettings, MaxSkinBones) == 0x000184, "Member 'URendererSettings::MaxSkinBones' has a wrong offset!");
static_assert(offsetof(URendererSettings, MobilePlanarReflectionMode) == 0x000188, "Member 'URendererSettings::MobilePlanarReflectionMode' has a wrong offset!");
static_assert(offsetof(URendererSettings, bStreamSkeletalMeshLODs) == 0x000190, "Member 'URendererSettings::bStreamSkeletalMeshLODs' has a wrong offset!");
static_assert(offsetof(URendererSettings, bDiscardSkeletalMeshOptionalLODs) == 0x000191, "Member 'URendererSettings::bDiscardSkeletalMeshOptionalLODs' has a wrong offset!");
static_assert(offsetof(URendererSettings, VisualizeCalibrationColorMaterialPath) == 0x000198, "Member 'URendererSettings::VisualizeCalibrationColorMaterialPath' has a wrong offset!");
static_assert(offsetof(URendererSettings, VisualizeCalibrationCustomMaterialPath) == 0x0001B8, "Member 'URendererSettings::VisualizeCalibrationCustomMaterialPath' has a wrong offset!");
static_assert(offsetof(URendererSettings, VisualizeCalibrationGrayscaleMaterialPath) == 0x0001D8, "Member 'URendererSettings::VisualizeCalibrationGrayscaleMaterialPath' has a wrong offset!");

// Class Engine.RendererOverrideSettings
// 0x0008 (0x0040 - 0x0038)
class URendererOverrideSettings final : public UDeveloperSettings
{
public:
	uint8                                         bSupportAllShaderPermutations : 1;                 // 0x0038(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_39[0x7];                                       // 0x0039(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"RendererOverrideSettings">();
	}
	static class URendererOverrideSettings* GetDefaultObj()
	{
		return GetDefaultObjImpl<URendererOverrideSettings>();
	}
};
static_assert(alignof(URendererOverrideSettings) == 0x000008, "Wrong alignment on URendererOverrideSettings");
static_assert(sizeof(URendererOverrideSettings) == 0x000040, "Wrong size on URendererOverrideSettings");

// Class Engine.SpecularProfile
// 0x0430 (0x0458 - 0x0028)
class USpecularProfile final : public UObject
{
public:
	struct FSpecularProfileStruct                 Settings;                                          // 0x0028(0x0420)(Edit, NativeAccessSpecifierPublic)
	struct FGuid                                  Guid;                                              // 0x0448(0x0010)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"SpecularProfile">();
	}
	static class USpecularProfile* GetDefaultObj()
	{
		return GetDefaultObjImpl<USpecularProfile>();
	}
};
static_assert(alignof(USpecularProfile) == 0x000008, "Wrong alignment on USpecularProfile");
static_assert(sizeof(USpecularProfile) == 0x000458, "Wrong size on USpecularProfile");
static_assert(offsetof(USpecularProfile, Settings) == 0x000028, "Member 'USpecularProfile::Settings' has a wrong offset!");
static_assert(offsetof(USpecularProfile, Guid) == 0x000448, "Member 'USpecularProfile::Guid' has a wrong offset!");

// Class Engine.ReplayNetConnection
// 0x0A88 (0x2880 - 0x1DF8)
class UReplayNetConnection final : public UNetConnection
{
public:
	uint8                                         Pad_1DF8[0xA88];                                   // 0x1DF8(0x0A88)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ReplayNetConnection">();
	}
	static class UReplayNetConnection* GetDefaultObj()
	{
		return GetDefaultObjImpl<UReplayNetConnection>();
	}
};
static_assert(alignof(UReplayNetConnection) == 0x000008, "Wrong alignment on UReplayNetConnection");
static_assert(sizeof(UReplayNetConnection) == 0x002880, "Wrong size on UReplayNetConnection");

// Class Engine.WorldPartitionVolume
// 0x0000 (0x02D8 - 0x02D8)
class AWorldPartitionVolume final : public AVolume
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"WorldPartitionVolume">();
	}
	static class AWorldPartitionVolume* GetDefaultObj()
	{
		return GetDefaultObjImpl<AWorldPartitionVolume>();
	}
};
static_assert(alignof(AWorldPartitionVolume) == 0x000008, "Wrong alignment on AWorldPartitionVolume");
static_assert(sizeof(AWorldPartitionVolume) == 0x0002D8, "Wrong size on AWorldPartitionVolume");

// Class Engine.GameInstanceSubsystem
// 0x0000 (0x0030 - 0x0030)
class UGameInstanceSubsystem : public USubsystem
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"GameInstanceSubsystem">();
	}
	static class UGameInstanceSubsystem* GetDefaultObj()
	{
		return GetDefaultObjImpl<UGameInstanceSubsystem>();
	}
};
static_assert(alignof(UGameInstanceSubsystem) == 0x000008, "Wrong alignment on UGameInstanceSubsystem");
static_assert(sizeof(UGameInstanceSubsystem) == 0x000030, "Wrong size on UGameInstanceSubsystem");

// Class Engine.ReplaySubsystem
// 0x0010 (0x0040 - 0x0030)
class UReplaySubsystem final : public UGameInstanceSubsystem
{
public:
	bool                                          bLoadDefaultMapOnStop;                             // 0x0030(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_31[0xF];                                       // 0x0031(0x000F)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void RequestCheckpoint();

	class FString GetActiveReplayName() const;
	float GetReplayCurrentTime() const;
	bool IsPlaying() const;
	bool IsRecording() const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ReplaySubsystem">();
	}
	static class UReplaySubsystem* GetDefaultObj()
	{
		return GetDefaultObjImpl<UReplaySubsystem>();
	}
};
static_assert(alignof(UReplaySubsystem) == 0x000008, "Wrong alignment on UReplaySubsystem");
static_assert(sizeof(UReplaySubsystem) == 0x000040, "Wrong size on UReplaySubsystem");
static_assert(offsetof(UReplaySubsystem, bLoadDefaultMapOnStop) == 0x000030, "Member 'UReplaySubsystem::bLoadDefaultMapOnStop' has a wrong offset!");

// Class Engine.RuntimeOptionsBase
// 0x0010 (0x0038 - 0x0028)
class URuntimeOptionsBase final : public UObject
{
public:
	uint8                                         Pad_28[0x10];                                      // 0x0028(0x0010)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"RuntimeOptionsBase">();
	}
	static class URuntimeOptionsBase* GetDefaultObj()
	{
		return GetDefaultObjImpl<URuntimeOptionsBase>();
	}
};
static_assert(alignof(URuntimeOptionsBase) == 0x000008, "Wrong alignment on URuntimeOptionsBase");
static_assert(sizeof(URuntimeOptionsBase) == 0x000038, "Wrong size on URuntimeOptionsBase");

// Class Engine.SCS_Node
// 0x00B0 (0x00D8 - 0x0028)
class USCS_Node final : public UObject
{
public:
	TSubclassOf<class UObject>                    ComponentClass;                                    // 0x0028(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UActorComponent*                        ComponentTemplate;                                 // 0x0030(0x0008)(ExportObject, ZeroConstructor, InstancedReference, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FBlueprintCookedComponentInstancingData CookedComponentInstancingData;                    // 0x0038(0x0048)(NativeAccessSpecifierPublic)
	class FName                                   AttachToName;                                      // 0x0080(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FName                                   ParentComponentOrVariableName;                     // 0x0088(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FName                                   ParentComponentOwnerClassName;                     // 0x0090(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bIsParentComponentNative;                          // 0x0098(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_99[0x7];                                       // 0x0099(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<class USCS_Node*>                      ChildNodes;                                        // 0x00A0(0x0010)(ZeroConstructor, UObjectWrapper, NativeAccessSpecifierPublic)
	TArray<struct FBPVariableMetaDataEntry>       MetaDataArray;                                     // 0x00B0(0x0010)(Edit, ZeroConstructor, NativeAccessSpecifierPublic)
	struct FGuid                                  VariableGuid;                                      // 0x00C0(0x0010)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FName                                   InternalVariableName;                              // 0x00D0(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"SCS_Node">();
	}
	static class USCS_Node* GetDefaultObj()
	{
		return GetDefaultObjImpl<USCS_Node>();
	}
};
static_assert(alignof(USCS_Node) == 0x000008, "Wrong alignment on USCS_Node");
static_assert(sizeof(USCS_Node) == 0x0000D8, "Wrong size on USCS_Node");
static_assert(offsetof(USCS_Node, ComponentClass) == 0x000028, "Member 'USCS_Node::ComponentClass' has a wrong offset!");
static_assert(offsetof(USCS_Node, ComponentTemplate) == 0x000030, "Member 'USCS_Node::ComponentTemplate' has a wrong offset!");
static_assert(offsetof(USCS_Node, CookedComponentInstancingData) == 0x000038, "Member 'USCS_Node::CookedComponentInstancingData' has a wrong offset!");
static_assert(offsetof(USCS_Node, AttachToName) == 0x000080, "Member 'USCS_Node::AttachToName' has a wrong offset!");
static_assert(offsetof(USCS_Node, ParentComponentOrVariableName) == 0x000088, "Member 'USCS_Node::ParentComponentOrVariableName' has a wrong offset!");
static_assert(offsetof(USCS_Node, ParentComponentOwnerClassName) == 0x000090, "Member 'USCS_Node::ParentComponentOwnerClassName' has a wrong offset!");
static_assert(offsetof(USCS_Node, bIsParentComponentNative) == 0x000098, "Member 'USCS_Node::bIsParentComponentNative' has a wrong offset!");
static_assert(offsetof(USCS_Node, ChildNodes) == 0x0000A0, "Member 'USCS_Node::ChildNodes' has a wrong offset!");
static_assert(offsetof(USCS_Node, MetaDataArray) == 0x0000B0, "Member 'USCS_Node::MetaDataArray' has a wrong offset!");
static_assert(offsetof(USCS_Node, VariableGuid) == 0x0000C0, "Member 'USCS_Node::VariableGuid' has a wrong offset!");
static_assert(offsetof(USCS_Node, InternalVariableName) == 0x0000D0, "Member 'USCS_Node::InternalVariableName' has a wrong offset!");

// Class Engine.SimpleConstructionScript
// 0x0088 (0x00B0 - 0x0028)
class USimpleConstructionScript final : public UObject
{
public:
	TArray<class USCS_Node*>                      RootNodes;                                         // 0x0028(0x0010)(ZeroConstructor, UObjectWrapper, NativeAccessSpecifierPrivate)
	TArray<class USCS_Node*>                      AllNodes;                                          // 0x0038(0x0010)(ZeroConstructor, UObjectWrapper, NativeAccessSpecifierPrivate)
	class USCS_Node*                              DefaultSceneRootNode;                              // 0x0048(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_50[0x60];                                      // 0x0050(0x0060)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"SimpleConstructionScript">();
	}
	static class USimpleConstructionScript* GetDefaultObj()
	{
		return GetDefaultObjImpl<USimpleConstructionScript>();
	}
};
static_assert(alignof(USimpleConstructionScript) == 0x000008, "Wrong alignment on USimpleConstructionScript");
static_assert(sizeof(USimpleConstructionScript) == 0x0000B0, "Wrong size on USimpleConstructionScript");
static_assert(offsetof(USimpleConstructionScript, RootNodes) == 0x000028, "Member 'USimpleConstructionScript::RootNodes' has a wrong offset!");
static_assert(offsetof(USimpleConstructionScript, AllNodes) == 0x000038, "Member 'USimpleConstructionScript::AllNodes' has a wrong offset!");
static_assert(offsetof(USimpleConstructionScript, DefaultSceneRootNode) == 0x000048, "Member 'USimpleConstructionScript::DefaultSceneRootNode' has a wrong offset!");

// Class Engine.SkeletalMesh
// 0x0410 (0x04E0 - 0x00D0)
class USkeletalMesh : public USkinnedAsset
{
public:
	uint8                                         Pad_D0[0x20];                                      // 0x00D0(0x0020)(Fixing Size After Last Property [ Dumper-7 ])
	class USkeleton*                              Skeleton;                                          // 0x00F0(0x0008)(Edit, BlueprintVisible, ZeroConstructor, EditConst, NoDestructor, AssetRegistrySearchable, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FBoxSphereBounds                       ImportedBounds;                                    // 0x00F8(0x0038)(ZeroConstructor, Transient, DuplicateTransient, IsPlainOldData, NoDestructor, NativeAccessSpecifierPrivate)
	struct FBoxSphereBounds                       ExtendedBounds;                                    // 0x0130(0x0038)(ZeroConstructor, Transient, DuplicateTransient, IsPlainOldData, NoDestructor, NativeAccessSpecifierPrivate)
	struct FVector                                PositiveBoundsExtension;                           // 0x0168(0x0018)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	struct FVector                                NegativeBoundsExtension;                           // 0x0180(0x0018)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	TArray<struct FSkeletalMaterial>              Materials;                                         // 0x0198(0x0010)(Edit, BlueprintVisible, ZeroConstructor, Transient, DuplicateTransient, NativeAccessSpecifierPublic)
	TArray<struct FSkeletalMeshLODInfo>           LODInfo;                                           // 0x01A8(0x0010)(Edit, EditFixedSize, ZeroConstructor, NativeAccessSpecifierPrivate)
	uint8                                         Pad_1B8[0x50];                                     // 0x01B8(0x0050)(Fixing Size After Last Property [ Dumper-7 ])
	struct FPerQualityLevelInt                    MinQualityLevelLOD;                                // 0x0208(0x0068)(Edit, NativeAccessSpecifierPublic)
	struct FPerPlatformInt                        MinLOD;                                            // 0x0270(0x0004)(Edit, NoDestructor, NativeAccessSpecifierPublic)
	struct FPerPlatformBool                       DisableBelowMinLodStripping;                       // 0x0274(0x0001)(Edit, NoDestructor, NativeAccessSpecifierPublic)
	uint8                                         bUseFullPrecisionUVs : 1;                          // 0x0275(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Deprecated, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bUseHighPrecisionTangentBasis : 1;                 // 0x0275(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Deprecated, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bHasBeenSimplified : 1;                            // 0x0275(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bHasVertexColors : 1;                              // 0x0275(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         BitPad_275_4 : 1;                                  // 0x0275(0x0001)(Fixing Bit-Field Size Between Bits [ Dumper-7 ])
	uint8                                         bEnablePerPolyCollision : 1;                       // 0x0275(0x0001)(BitIndex: 0x05, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_276[0x2];                                      // 0x0276(0x0002)(Fixing Size After Last Property [ Dumper-7 ])
	class UBodySetup*                             BodySetup;                                         // 0x0278(0x0008)(ZeroConstructor, Transient, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UPhysicsAsset*                          PhysicsAsset;                                      // 0x0280(0x0008)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, NoDestructor, AssetRegistrySearchable, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UPhysicsAsset*                          ShadowPhysicsAsset;                                // 0x0288(0x0008)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, NoDestructor, AssetRegistrySearchable, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TArray<class UNodeMappingContainer*>          NodeMappingData;                                   // 0x0290(0x0010)(Edit, BlueprintVisible, BlueprintReadOnly, EditFixedSize, ZeroConstructor, UObjectWrapper, NativeAccessSpecifierPublic)
	uint8                                         bSupportRayTracing : 1;                            // 0x02A0(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_2A1[0x3];                                      // 0x02A1(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	int32                                         RayTracingMinLOD;                                  // 0x02A4(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EClothLODBiasMode                             ClothLODBiasMode;                                  // 0x02A8(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_2A9[0x7];                                      // 0x02A9(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<class UMorphTarget*>                   MorphTargets;                                      // 0x02B0(0x0010)(BlueprintVisible, ZeroConstructor, UObjectWrapper, NativeAccessSpecifierPublic)
	uint8                                         Pad_2C0[0x178];                                    // 0x02C0(0x0178)(Fixing Size After Last Property [ Dumper-7 ])
	TSubclassOf<class UAnimInstance>              PostProcessAnimBlueprint;                          // 0x0438(0x0008)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         PostProcessAnimBPLODThreshold;                     // 0x0440(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_444[0x4];                                      // 0x0444(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<class UClothingAssetBase*>             MeshClothingAssets;                                // 0x0448(0x0010)(Edit, BlueprintVisible, EditFixedSize, ZeroConstructor, UObjectWrapper, NativeAccessSpecifierPublic)
	struct FSkeletalMeshSamplingInfo              SamplingInfo;                                      // 0x0458(0x0030)(Edit, Protected, NativeAccessSpecifierProtected)
	TArray<class UAssetUserData*>                 AssetUserData;                                     // 0x0488(0x0010)(Edit, ExportObject, ZeroConstructor, ContainsInstancedReference, AdvancedDisplay, Protected, UObjectWrapper, NativeAccessSpecifierProtected)
	TArray<class USkeletalMeshSocket*>            Sockets;                                           // 0x0498(0x0010)(ZeroConstructor, UObjectWrapper, NativeAccessSpecifierPrivate)
	uint8                                         Pad_4A8[0x10];                                     // 0x04A8(0x0010)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<struct FSkinWeightProfileInfo>         SkinWeightProfiles;                                // 0x04B8(0x0010)(Edit, EditFixedSize, ZeroConstructor, Protected, NativeAccessSpecifierProtected)
	class UMeshDeformer*                          DefaultMeshDeformer;                               // 0x04C8(0x0008)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, NoDestructor, Protected, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	class UMaterialInterface*                     OverlayMaterial;                                   // 0x04D0(0x0008)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, NoDestructor, Protected, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	float                                         OverlayMaterialMaxDrawDistance;                    // 0x04D8(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_4DC[0x4];                                      // 0x04DC(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void SetDefaultAnimatingRig(TSoftObjectPtr<class UObject> InAnimatingRig);
	void SetLODSettings(class USkeletalMeshLODSettings* InLODSettings);
	void SetMaterials(const TArray<struct FSkeletalMaterial>& InMaterials);
	void SetMeshClothingAssets(const TArray<class UClothingAssetBase*>& InMeshClothingAssets);
	void SetMinLODForQualityLevels(const TMap<EPerQualityLevels, int32>& QualityLevelMinimumLODs, int32 Default);
	void SetMorphTargets(const TArray<class UMorphTarget*>& InMorphTargets);
	void SetOverlayMaterial(class UMaterialInterface* NewOverlayMaterial);
	void SetOverlayMaterialMaxDrawDistance(float InMaxDrawDistance);
	void SetSkeleton(class USkeleton* InSkeleton);

	class USkeletalMeshSocket* FindSocketAndIndex(class FName InSocketName, int32* OutIndex) const;
	struct FBoxSphereBounds GetBounds() const;
	TSoftObjectPtr<class UObject> GetDefaultAnimatingRig() const;
	struct FBoxSphereBounds GetImportedBounds() const;
	const class USkeletalMeshLODSettings* GetLODSettings() const;
	const TArray<struct FSkeletalMaterial> GetMaterials() const;
	const TArray<class UClothingAssetBase*> GetMeshClothingAssets() const;
	void GetMinLODForQualityLevels(TMap<EPerQualityLevels, int32>* QualityLevelMinimumLODs, int32* Default) const;
	TArray<class UMorphTarget*> GetMorphTargetsPtrConv() const;
	class UNodeMappingContainer* GetNodeMappingContainer(class UBlueprint* SourceAsset) const;
	const TArray<class UNodeMappingContainer*> GetNodeMappingData() const;
	class UMaterialInterface* GetOverlayMaterial() const;
	float GetOverlayMaterialMaxDrawDistance() const;
	class UPhysicsAsset* GetPhysicsAsset() const;
	class UPhysicsAsset* GetShadowPhysicsAsset() const;
	const class USkeleton* GetSkeleton() const;
	class USkeletalMeshSocket* GetSocketByIndex(int32 Index_0) const;
	bool IsSectionUsingCloth(int32 InSectionIndex, bool bCheckCorrespondingSections) const;
	TArray<class FString> K2_GetAllMorphTargetNames() const;
	int32 NumSockets() const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"SkeletalMesh">();
	}
	static class USkeletalMesh* GetDefaultObj()
	{
		return GetDefaultObjImpl<USkeletalMesh>();
	}
};
static_assert(alignof(USkeletalMesh) == 0x000008, "Wrong alignment on USkeletalMesh");
static_assert(sizeof(USkeletalMesh) == 0x0004E0, "Wrong size on USkeletalMesh");
static_assert(offsetof(USkeletalMesh, Skeleton) == 0x0000F0, "Member 'USkeletalMesh::Skeleton' has a wrong offset!");
static_assert(offsetof(USkeletalMesh, ImportedBounds) == 0x0000F8, "Member 'USkeletalMesh::ImportedBounds' has a wrong offset!");
static_assert(offsetof(USkeletalMesh, ExtendedBounds) == 0x000130, "Member 'USkeletalMesh::ExtendedBounds' has a wrong offset!");
static_assert(offsetof(USkeletalMesh, PositiveBoundsExtension) == 0x000168, "Member 'USkeletalMesh::PositiveBoundsExtension' has a wrong offset!");
static_assert(offsetof(USkeletalMesh, NegativeBoundsExtension) == 0x000180, "Member 'USkeletalMesh::NegativeBoundsExtension' has a wrong offset!");
static_assert(offsetof(USkeletalMesh, Materials) == 0x000198, "Member 'USkeletalMesh::Materials' has a wrong offset!");
static_assert(offsetof(USkeletalMesh, LODInfo) == 0x0001A8, "Member 'USkeletalMesh::LODInfo' has a wrong offset!");
static_assert(offsetof(USkeletalMesh, MinQualityLevelLOD) == 0x000208, "Member 'USkeletalMesh::MinQualityLevelLOD' has a wrong offset!");
static_assert(offsetof(USkeletalMesh, MinLOD) == 0x000270, "Member 'USkeletalMesh::MinLOD' has a wrong offset!");
static_assert(offsetof(USkeletalMesh, DisableBelowMinLodStripping) == 0x000274, "Member 'USkeletalMesh::DisableBelowMinLodStripping' has a wrong offset!");
static_assert(offsetof(USkeletalMesh, BodySetup) == 0x000278, "Member 'USkeletalMesh::BodySetup' has a wrong offset!");
static_assert(offsetof(USkeletalMesh, PhysicsAsset) == 0x000280, "Member 'USkeletalMesh::PhysicsAsset' has a wrong offset!");
static_assert(offsetof(USkeletalMesh, ShadowPhysicsAsset) == 0x000288, "Member 'USkeletalMesh::ShadowPhysicsAsset' has a wrong offset!");
static_assert(offsetof(USkeletalMesh, NodeMappingData) == 0x000290, "Member 'USkeletalMesh::NodeMappingData' has a wrong offset!");
static_assert(offsetof(USkeletalMesh, RayTracingMinLOD) == 0x0002A4, "Member 'USkeletalMesh::RayTracingMinLOD' has a wrong offset!");
static_assert(offsetof(USkeletalMesh, ClothLODBiasMode) == 0x0002A8, "Member 'USkeletalMesh::ClothLODBiasMode' has a wrong offset!");
static_assert(offsetof(USkeletalMesh, MorphTargets) == 0x0002B0, "Member 'USkeletalMesh::MorphTargets' has a wrong offset!");
static_assert(offsetof(USkeletalMesh, PostProcessAnimBlueprint) == 0x000438, "Member 'USkeletalMesh::PostProcessAnimBlueprint' has a wrong offset!");
static_assert(offsetof(USkeletalMesh, PostProcessAnimBPLODThreshold) == 0x000440, "Member 'USkeletalMesh::PostProcessAnimBPLODThreshold' has a wrong offset!");
static_assert(offsetof(USkeletalMesh, MeshClothingAssets) == 0x000448, "Member 'USkeletalMesh::MeshClothingAssets' has a wrong offset!");
static_assert(offsetof(USkeletalMesh, SamplingInfo) == 0x000458, "Member 'USkeletalMesh::SamplingInfo' has a wrong offset!");
static_assert(offsetof(USkeletalMesh, AssetUserData) == 0x000488, "Member 'USkeletalMesh::AssetUserData' has a wrong offset!");
static_assert(offsetof(USkeletalMesh, Sockets) == 0x000498, "Member 'USkeletalMesh::Sockets' has a wrong offset!");
static_assert(offsetof(USkeletalMesh, SkinWeightProfiles) == 0x0004B8, "Member 'USkeletalMesh::SkinWeightProfiles' has a wrong offset!");
static_assert(offsetof(USkeletalMesh, DefaultMeshDeformer) == 0x0004C8, "Member 'USkeletalMesh::DefaultMeshDeformer' has a wrong offset!");
static_assert(offsetof(USkeletalMesh, OverlayMaterial) == 0x0004D0, "Member 'USkeletalMesh::OverlayMaterial' has a wrong offset!");
static_assert(offsetof(USkeletalMesh, OverlayMaterialMaxDrawDistance) == 0x0004D8, "Member 'USkeletalMesh::OverlayMaterialMaxDrawDistance' has a wrong offset!");

// Class Engine.SkeletalMeshEditorData
// 0x0000 (0x0028 - 0x0028)
class USkeletalMeshEditorData final : public UObject
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"SkeletalMeshEditorData">();
	}
	static class USkeletalMeshEditorData* GetDefaultObj()
	{
		return GetDefaultObjImpl<USkeletalMeshEditorData>();
	}
};
static_assert(alignof(USkeletalMeshEditorData) == 0x000008, "Wrong alignment on USkeletalMeshEditorData");
static_assert(sizeof(USkeletalMeshEditorData) == 0x000028, "Wrong size on USkeletalMeshEditorData");

// Class Engine.SkeletalMeshLODSettings
// 0x0088 (0x00B8 - 0x0030)
class USkeletalMeshLODSettings final : public UDataAsset
{
public:
	struct FPerQualityLevelInt                    MinQualityLevelLOD;                                // 0x0030(0x0068)(Edit, Config, GlobalConfig, Protected, NativeAccessSpecifierProtected)
	struct FPerPlatformInt                        MinLOD;                                            // 0x0098(0x0004)(Edit, Config, GlobalConfig, NoDestructor, Protected, NativeAccessSpecifierProtected)
	struct FPerPlatformBool                       DisableBelowMinLodStripping;                       // 0x009C(0x0001)(Edit, Config, GlobalConfig, NoDestructor, Protected, NativeAccessSpecifierProtected)
	bool                                          bOverrideLODStreamingSettings;                     // 0x009D(0x0001)(Edit, ZeroConstructor, Config, GlobalConfig, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	struct FPerPlatformBool                       bSupportLODStreaming;                              // 0x009E(0x0001)(Edit, Config, GlobalConfig, NoDestructor, Protected, NativeAccessSpecifierProtected)
	uint8                                         Pad_9F[0x1];                                       // 0x009F(0x0001)(Fixing Size After Last Property [ Dumper-7 ])
	struct FPerPlatformInt                        MaxNumStreamedLODs;                                // 0x00A0(0x0004)(Edit, Config, GlobalConfig, NoDestructor, Protected, NativeAccessSpecifierProtected)
	struct FPerPlatformInt                        MaxNumOptionalLODs;                                // 0x00A4(0x0004)(Edit, Config, GlobalConfig, NoDestructor, Protected, NativeAccessSpecifierProtected)
	TArray<struct FSkeletalMeshLODGroupSettings>  LODGroups;                                         // 0x00A8(0x0010)(Edit, ZeroConstructor, Config, GlobalConfig, Protected, NativeAccessSpecifierProtected)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"SkeletalMeshLODSettings">();
	}
	static class USkeletalMeshLODSettings* GetDefaultObj()
	{
		return GetDefaultObjImpl<USkeletalMeshLODSettings>();
	}
};
static_assert(alignof(USkeletalMeshLODSettings) == 0x000008, "Wrong alignment on USkeletalMeshLODSettings");
static_assert(sizeof(USkeletalMeshLODSettings) == 0x0000B8, "Wrong size on USkeletalMeshLODSettings");
static_assert(offsetof(USkeletalMeshLODSettings, MinQualityLevelLOD) == 0x000030, "Member 'USkeletalMeshLODSettings::MinQualityLevelLOD' has a wrong offset!");
static_assert(offsetof(USkeletalMeshLODSettings, MinLOD) == 0x000098, "Member 'USkeletalMeshLODSettings::MinLOD' has a wrong offset!");
static_assert(offsetof(USkeletalMeshLODSettings, DisableBelowMinLodStripping) == 0x00009C, "Member 'USkeletalMeshLODSettings::DisableBelowMinLodStripping' has a wrong offset!");
static_assert(offsetof(USkeletalMeshLODSettings, bOverrideLODStreamingSettings) == 0x00009D, "Member 'USkeletalMeshLODSettings::bOverrideLODStreamingSettings' has a wrong offset!");
static_assert(offsetof(USkeletalMeshLODSettings, bSupportLODStreaming) == 0x00009E, "Member 'USkeletalMeshLODSettings::bSupportLODStreaming' has a wrong offset!");
static_assert(offsetof(USkeletalMeshLODSettings, MaxNumStreamedLODs) == 0x0000A0, "Member 'USkeletalMeshLODSettings::MaxNumStreamedLODs' has a wrong offset!");
static_assert(offsetof(USkeletalMeshLODSettings, MaxNumOptionalLODs) == 0x0000A4, "Member 'USkeletalMeshLODSettings::MaxNumOptionalLODs' has a wrong offset!");
static_assert(offsetof(USkeletalMeshLODSettings, LODGroups) == 0x0000A8, "Member 'USkeletalMeshLODSettings::LODGroups' has a wrong offset!");

// Class Engine.ButtonStyleAsset
// 0x03F8 (0x0420 - 0x0028)
class UButtonStyleAsset final : public UObject
{
public:
	uint8                                         Pad_28[0x8];                                       // 0x0028(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	struct FButtonStyle                           ButtonStyle;                                       // 0x0030(0x03F0)(Edit, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ButtonStyleAsset">();
	}
	static class UButtonStyleAsset* GetDefaultObj()
	{
		return GetDefaultObjImpl<UButtonStyleAsset>();
	}
};
static_assert(alignof(UButtonStyleAsset) == 0x000010, "Wrong alignment on UButtonStyleAsset");
static_assert(sizeof(UButtonStyleAsset) == 0x000420, "Wrong size on UButtonStyleAsset");
static_assert(offsetof(UButtonStyleAsset, ButtonStyle) == 0x000030, "Member 'UButtonStyleAsset::ButtonStyle' has a wrong offset!");

// Class Engine.CheckBoxStyleAsset
// 0x0AD8 (0x0B00 - 0x0028)
class UCheckBoxStyleAsset final : public UObject
{
public:
	uint8                                         Pad_28[0x8];                                       // 0x0028(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	struct FCheckBoxStyle                         CheckBoxStyle;                                     // 0x0030(0x0AD0)(Edit, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"CheckBoxStyleAsset">();
	}
	static class UCheckBoxStyleAsset* GetDefaultObj()
	{
		return GetDefaultObjImpl<UCheckBoxStyleAsset>();
	}
};
static_assert(alignof(UCheckBoxStyleAsset) == 0x000010, "Wrong alignment on UCheckBoxStyleAsset");
static_assert(sizeof(UCheckBoxStyleAsset) == 0x000B00, "Wrong size on UCheckBoxStyleAsset");
static_assert(offsetof(UCheckBoxStyleAsset, CheckBoxStyle) == 0x000030, "Member 'UCheckBoxStyleAsset::CheckBoxStyle' has a wrong offset!");

// Class Engine.SlateBrushAsset
// 0x00D8 (0x0100 - 0x0028)
class USlateBrushAsset final : public UObject
{
public:
	uint8                                         Pad_28[0x8];                                       // 0x0028(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	struct FSlateBrush                            Brush;                                             // 0x0030(0x00D0)(Edit, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"SlateBrushAsset">();
	}
	static class USlateBrushAsset* GetDefaultObj()
	{
		return GetDefaultObjImpl<USlateBrushAsset>();
	}
};
static_assert(alignof(USlateBrushAsset) == 0x000010, "Wrong alignment on USlateBrushAsset");
static_assert(sizeof(USlateBrushAsset) == 0x000100, "Wrong size on USlateBrushAsset");
static_assert(offsetof(USlateBrushAsset, Brush) == 0x000030, "Member 'USlateBrushAsset::Brush' has a wrong offset!");

// Class Engine.SoundClass
// 0x01C0 (0x01E8 - 0x0028)
class USoundClass final : public UObject
{
public:
	struct FSoundClassProperties                  Properties;                                        // 0x0028(0x0198)(Edit, BlueprintVisible, BlueprintReadOnly, NativeAccessSpecifierPublic)
	TArray<class USoundClass*>                    ChildClasses;                                      // 0x01C0(0x0010)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, UObjectWrapper, NativeAccessSpecifierPublic)
	TArray<struct FPassiveSoundMixModifier>       PassiveSoundMixModifiers;                          // 0x01D0(0x0010)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, NativeAccessSpecifierPublic)
	class USoundClass*                            ParentClass;                                       // 0x01E0(0x0008)(BlueprintVisible, BlueprintReadOnly, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"SoundClass">();
	}
	static class USoundClass* GetDefaultObj()
	{
		return GetDefaultObjImpl<USoundClass>();
	}
};
static_assert(alignof(USoundClass) == 0x000008, "Wrong alignment on USoundClass");
static_assert(sizeof(USoundClass) == 0x0001E8, "Wrong size on USoundClass");
static_assert(offsetof(USoundClass, Properties) == 0x000028, "Member 'USoundClass::Properties' has a wrong offset!");
static_assert(offsetof(USoundClass, ChildClasses) == 0x0001C0, "Member 'USoundClass::ChildClasses' has a wrong offset!");
static_assert(offsetof(USoundClass, PassiveSoundMixModifiers) == 0x0001D0, "Member 'USoundClass::PassiveSoundMixModifiers' has a wrong offset!");
static_assert(offsetof(USoundClass, ParentClass) == 0x0001E0, "Member 'USoundClass::ParentClass' has a wrong offset!");

// Class Engine.SoundConcurrency
// 0x0020 (0x0048 - 0x0028)
class USoundConcurrency final : public UObject
{
public:
	struct FSoundConcurrencySettings              Concurrency;                                       // 0x0028(0x0020)(Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"SoundConcurrency">();
	}
	static class USoundConcurrency* GetDefaultObj()
	{
		return GetDefaultObjImpl<USoundConcurrency>();
	}
};
static_assert(alignof(USoundConcurrency) == 0x000008, "Wrong alignment on USoundConcurrency");
static_assert(sizeof(USoundConcurrency) == 0x000048, "Wrong size on USoundConcurrency");
static_assert(offsetof(USoundConcurrency, Concurrency) == 0x000028, "Member 'USoundConcurrency::Concurrency' has a wrong offset!");

// Class Engine.SoundCue
// 0x03F8 (0x0560 - 0x0168)
class USoundCue final : public USoundBase
{
public:
	class USoundNode*                             FirstNode;                                         // 0x0168(0x0008)(BlueprintVisible, BlueprintReadOnly, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         VolumeMultiplier;                                  // 0x0170(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, AssetRegistrySearchable, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         PitchMultiplier;                                   // 0x0174(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, AssetRegistrySearchable, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FSoundAttenuationSettings              AttenuationOverrides;                              // 0x0178(0x03D0)(Edit, NativeAccessSpecifierPublic)
	float                                         SubtitlePriority;                                  // 0x0548(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_54C[0x4];                                      // 0x054C(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	uint8                                         bPrimeOnLoad : 1;                                  // 0x0550(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bOverrideAttenuation : 1;                          // 0x0550(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bExcludeFromRandomNodeBranchCulling : 1;           // 0x0550(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bHasPlayWhenSilent : 1;                            // 0x0550(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate))
	uint8                                         Pad_551[0x3];                                      // 0x0551(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	int32                                         CookedQualityIndex;                                // 0x0554(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_558[0x8];                                      // 0x0558(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"SoundCue">();
	}
	static class USoundCue* GetDefaultObj()
	{
		return GetDefaultObjImpl<USoundCue>();
	}
};
static_assert(alignof(USoundCue) == 0x000008, "Wrong alignment on USoundCue");
static_assert(sizeof(USoundCue) == 0x000560, "Wrong size on USoundCue");
static_assert(offsetof(USoundCue, FirstNode) == 0x000168, "Member 'USoundCue::FirstNode' has a wrong offset!");
static_assert(offsetof(USoundCue, VolumeMultiplier) == 0x000170, "Member 'USoundCue::VolumeMultiplier' has a wrong offset!");
static_assert(offsetof(USoundCue, PitchMultiplier) == 0x000174, "Member 'USoundCue::PitchMultiplier' has a wrong offset!");
static_assert(offsetof(USoundCue, AttenuationOverrides) == 0x000178, "Member 'USoundCue::AttenuationOverrides' has a wrong offset!");
static_assert(offsetof(USoundCue, SubtitlePriority) == 0x000548, "Member 'USoundCue::SubtitlePriority' has a wrong offset!");
static_assert(offsetof(USoundCue, CookedQualityIndex) == 0x000554, "Member 'USoundCue::CookedQualityIndex' has a wrong offset!");

// Class Engine.SoundNodeAssetReferencer
// 0x0000 (0x0048 - 0x0048)
class USoundNodeAssetReferencer : public USoundNode
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"SoundNodeAssetReferencer">();
	}
	static class USoundNodeAssetReferencer* GetDefaultObj()
	{
		return GetDefaultObjImpl<USoundNodeAssetReferencer>();
	}
};
static_assert(alignof(USoundNodeAssetReferencer) == 0x000008, "Wrong alignment on USoundNodeAssetReferencer");
static_assert(sizeof(USoundNodeAssetReferencer) == 0x000048, "Wrong size on USoundNodeAssetReferencer");

// Class Engine.SoundNodeAttenuation
// 0x03E0 (0x0428 - 0x0048)
class USoundNodeAttenuation final : public USoundNode
{
public:
	class USoundAttenuation*                      AttenuationSettings;                               // 0x0048(0x0008)(Edit, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FSoundAttenuationSettings              AttenuationOverrides;                              // 0x0050(0x03D0)(Edit, NativeAccessSpecifierPublic)
	uint8                                         bOverrideAttenuation : 1;                          // 0x0420(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_421[0x7];                                      // 0x0421(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"SoundNodeAttenuation">();
	}
	static class USoundNodeAttenuation* GetDefaultObj()
	{
		return GetDefaultObjImpl<USoundNodeAttenuation>();
	}
};
static_assert(alignof(USoundNodeAttenuation) == 0x000008, "Wrong alignment on USoundNodeAttenuation");
static_assert(sizeof(USoundNodeAttenuation) == 0x000428, "Wrong size on USoundNodeAttenuation");
static_assert(offsetof(USoundNodeAttenuation, AttenuationSettings) == 0x000048, "Member 'USoundNodeAttenuation::AttenuationSettings' has a wrong offset!");
static_assert(offsetof(USoundNodeAttenuation, AttenuationOverrides) == 0x000050, "Member 'USoundNodeAttenuation::AttenuationOverrides' has a wrong offset!");

// Class Engine.SoundNodeBranch
// 0x0008 (0x0050 - 0x0048)
class USoundNodeBranch final : public USoundNode
{
public:
	class FName                                   BoolParameterName;                                 // 0x0048(0x0008)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"SoundNodeBranch">();
	}
	static class USoundNodeBranch* GetDefaultObj()
	{
		return GetDefaultObjImpl<USoundNodeBranch>();
	}
};
static_assert(alignof(USoundNodeBranch) == 0x000008, "Wrong alignment on USoundNodeBranch");
static_assert(sizeof(USoundNodeBranch) == 0x000050, "Wrong size on USoundNodeBranch");
static_assert(offsetof(USoundNodeBranch, BoolParameterName) == 0x000048, "Member 'USoundNodeBranch::BoolParameterName' has a wrong offset!");

// Class Engine.SoundNodeDelay
// 0x0008 (0x0050 - 0x0048)
class USoundNodeDelay final : public USoundNode
{
public:
	float                                         DelayMin;                                          // 0x0048(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         DelayMax;                                          // 0x004C(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"SoundNodeDelay">();
	}
	static class USoundNodeDelay* GetDefaultObj()
	{
		return GetDefaultObjImpl<USoundNodeDelay>();
	}
};
static_assert(alignof(USoundNodeDelay) == 0x000008, "Wrong alignment on USoundNodeDelay");
static_assert(sizeof(USoundNodeDelay) == 0x000050, "Wrong size on USoundNodeDelay");
static_assert(offsetof(USoundNodeDelay, DelayMin) == 0x000048, "Member 'USoundNodeDelay::DelayMin' has a wrong offset!");
static_assert(offsetof(USoundNodeDelay, DelayMax) == 0x00004C, "Member 'USoundNodeDelay::DelayMax' has a wrong offset!");

// Class Engine.SoundNodeDialoguePlayer
// 0x0028 (0x0070 - 0x0048)
class USoundNodeDialoguePlayer final : public USoundNode
{
public:
	struct FDialogueWaveParameter                 DialogueWaveParameter;                             // 0x0048(0x0020)(Edit, NativeAccessSpecifierPublic)
	uint8                                         bLooping : 1;                                      // 0x0068(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_69[0x7];                                       // 0x0069(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"SoundNodeDialoguePlayer">();
	}
	static class USoundNodeDialoguePlayer* GetDefaultObj()
	{
		return GetDefaultObjImpl<USoundNodeDialoguePlayer>();
	}
};
static_assert(alignof(USoundNodeDialoguePlayer) == 0x000008, "Wrong alignment on USoundNodeDialoguePlayer");
static_assert(sizeof(USoundNodeDialoguePlayer) == 0x000070, "Wrong size on USoundNodeDialoguePlayer");
static_assert(offsetof(USoundNodeDialoguePlayer, DialogueWaveParameter) == 0x000048, "Member 'USoundNodeDialoguePlayer::DialogueWaveParameter' has a wrong offset!");

// Class Engine.SoundNodeGroupControl
// 0x0010 (0x0058 - 0x0048)
class USoundNodeGroupControl final : public USoundNode
{
public:
	TArray<int32>                                 GroupSizes;                                        // 0x0048(0x0010)(Edit, EditFixedSize, ZeroConstructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"SoundNodeGroupControl">();
	}
	static class USoundNodeGroupControl* GetDefaultObj()
	{
		return GetDefaultObjImpl<USoundNodeGroupControl>();
	}
};
static_assert(alignof(USoundNodeGroupControl) == 0x000008, "Wrong alignment on USoundNodeGroupControl");
static_assert(sizeof(USoundNodeGroupControl) == 0x000058, "Wrong size on USoundNodeGroupControl");
static_assert(offsetof(USoundNodeGroupControl, GroupSizes) == 0x000048, "Member 'USoundNodeGroupControl::GroupSizes' has a wrong offset!");

// Class Engine.SoundNodeLooping
// 0x0008 (0x0050 - 0x0048)
class USoundNodeLooping final : public USoundNode
{
public:
	int32                                         LoopCount;                                         // 0x0048(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bLoopIndefinitely : 1;                             // 0x004C(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_4D[0x3];                                       // 0x004D(0x0003)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"SoundNodeLooping">();
	}
	static class USoundNodeLooping* GetDefaultObj()
	{
		return GetDefaultObjImpl<USoundNodeLooping>();
	}
};
static_assert(alignof(USoundNodeLooping) == 0x000008, "Wrong alignment on USoundNodeLooping");
static_assert(sizeof(USoundNodeLooping) == 0x000050, "Wrong size on USoundNodeLooping");
static_assert(offsetof(USoundNodeLooping, LoopCount) == 0x000048, "Member 'USoundNodeLooping::LoopCount' has a wrong offset!");

// Class Engine.SoundNodeModulator
// 0x0010 (0x0058 - 0x0048)
class USoundNodeModulator final : public USoundNode
{
public:
	float                                         PitchMin;                                          // 0x0048(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         PitchMax;                                          // 0x004C(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         VolumeMin;                                         // 0x0050(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         VolumeMax;                                         // 0x0054(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"SoundNodeModulator">();
	}
	static class USoundNodeModulator* GetDefaultObj()
	{
		return GetDefaultObjImpl<USoundNodeModulator>();
	}
};
static_assert(alignof(USoundNodeModulator) == 0x000008, "Wrong alignment on USoundNodeModulator");
static_assert(sizeof(USoundNodeModulator) == 0x000058, "Wrong size on USoundNodeModulator");
static_assert(offsetof(USoundNodeModulator, PitchMin) == 0x000048, "Member 'USoundNodeModulator::PitchMin' has a wrong offset!");
static_assert(offsetof(USoundNodeModulator, PitchMax) == 0x00004C, "Member 'USoundNodeModulator::PitchMax' has a wrong offset!");
static_assert(offsetof(USoundNodeModulator, VolumeMin) == 0x000050, "Member 'USoundNodeModulator::VolumeMin' has a wrong offset!");
static_assert(offsetof(USoundNodeModulator, VolumeMax) == 0x000054, "Member 'USoundNodeModulator::VolumeMax' has a wrong offset!");

// Class Engine.SoundNodeOscillator
// 0x0028 (0x0070 - 0x0048)
class USoundNodeOscillator final : public USoundNode
{
public:
	uint8                                         bModulateVolume : 1;                               // 0x0048(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bModulatePitch : 1;                                // 0x0048(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_49[0x3];                                       // 0x0049(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         AmplitudeMin;                                      // 0x004C(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         AmplitudeMax;                                      // 0x0050(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         FrequencyMin;                                      // 0x0054(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         FrequencyMax;                                      // 0x0058(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         OffsetMin;                                         // 0x005C(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         OffsetMax;                                         // 0x0060(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         CenterMin;                                         // 0x0064(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         CenterMax;                                         // 0x0068(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_6C[0x4];                                       // 0x006C(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"SoundNodeOscillator">();
	}
	static class USoundNodeOscillator* GetDefaultObj()
	{
		return GetDefaultObjImpl<USoundNodeOscillator>();
	}
};
static_assert(alignof(USoundNodeOscillator) == 0x000008, "Wrong alignment on USoundNodeOscillator");
static_assert(sizeof(USoundNodeOscillator) == 0x000070, "Wrong size on USoundNodeOscillator");
static_assert(offsetof(USoundNodeOscillator, AmplitudeMin) == 0x00004C, "Member 'USoundNodeOscillator::AmplitudeMin' has a wrong offset!");
static_assert(offsetof(USoundNodeOscillator, AmplitudeMax) == 0x000050, "Member 'USoundNodeOscillator::AmplitudeMax' has a wrong offset!");
static_assert(offsetof(USoundNodeOscillator, FrequencyMin) == 0x000054, "Member 'USoundNodeOscillator::FrequencyMin' has a wrong offset!");
static_assert(offsetof(USoundNodeOscillator, FrequencyMax) == 0x000058, "Member 'USoundNodeOscillator::FrequencyMax' has a wrong offset!");
static_assert(offsetof(USoundNodeOscillator, OffsetMin) == 0x00005C, "Member 'USoundNodeOscillator::OffsetMin' has a wrong offset!");
static_assert(offsetof(USoundNodeOscillator, OffsetMax) == 0x000060, "Member 'USoundNodeOscillator::OffsetMax' has a wrong offset!");
static_assert(offsetof(USoundNodeOscillator, CenterMin) == 0x000064, "Member 'USoundNodeOscillator::CenterMin' has a wrong offset!");
static_assert(offsetof(USoundNodeOscillator, CenterMax) == 0x000068, "Member 'USoundNodeOscillator::CenterMax' has a wrong offset!");

// Class Engine.SoundNodeRandom
// 0x0030 (0x0078 - 0x0048)
class USoundNodeRandom final : public USoundNode
{
public:
	TArray<float>                                 Weights;                                           // 0x0048(0x0010)(Edit, EditFixedSize, ZeroConstructor, NativeAccessSpecifierPublic)
	TArray<bool>                                  HasBeenUsed;                                       // 0x0058(0x0010)(ZeroConstructor, Transient, NativeAccessSpecifierPublic)
	int32                                         NumRandomUsed;                                     // 0x0068(0x0004)(ZeroConstructor, Transient, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         PreselectAtLevelLoad;                              // 0x006C(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bShouldExcludeFromBranchCulling : 1;               // 0x0070(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bSoundCueExcludedFromBranchCulling : 1;            // 0x0070(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bRandomizeWithoutReplacement : 1;                  // 0x0070(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_71[0x7];                                       // 0x0071(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"SoundNodeRandom">();
	}
	static class USoundNodeRandom* GetDefaultObj()
	{
		return GetDefaultObjImpl<USoundNodeRandom>();
	}
};
static_assert(alignof(USoundNodeRandom) == 0x000008, "Wrong alignment on USoundNodeRandom");
static_assert(sizeof(USoundNodeRandom) == 0x000078, "Wrong size on USoundNodeRandom");
static_assert(offsetof(USoundNodeRandom, Weights) == 0x000048, "Member 'USoundNodeRandom::Weights' has a wrong offset!");
static_assert(offsetof(USoundNodeRandom, HasBeenUsed) == 0x000058, "Member 'USoundNodeRandom::HasBeenUsed' has a wrong offset!");
static_assert(offsetof(USoundNodeRandom, NumRandomUsed) == 0x000068, "Member 'USoundNodeRandom::NumRandomUsed' has a wrong offset!");
static_assert(offsetof(USoundNodeRandom, PreselectAtLevelLoad) == 0x00006C, "Member 'USoundNodeRandom::PreselectAtLevelLoad' has a wrong offset!");

// Class Engine.SoundNodeSoundClass
// 0x0010 (0x0058 - 0x0048)
class USoundNodeSoundClass final : public USoundNode
{
public:
	class USoundClass*                            SoundClassOverride;                                // 0x0048(0x0008)(Edit, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_50[0x8];                                       // 0x0050(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"SoundNodeSoundClass">();
	}
	static class USoundNodeSoundClass* GetDefaultObj()
	{
		return GetDefaultObjImpl<USoundNodeSoundClass>();
	}
};
static_assert(alignof(USoundNodeSoundClass) == 0x000008, "Wrong alignment on USoundNodeSoundClass");
static_assert(sizeof(USoundNodeSoundClass) == 0x000058, "Wrong size on USoundNodeSoundClass");
static_assert(offsetof(USoundNodeSoundClass, SoundClassOverride) == 0x000048, "Member 'USoundNodeSoundClass::SoundClassOverride' has a wrong offset!");

// Class Engine.SoundNodeWavePlayer
// 0x0038 (0x0080 - 0x0048)
class USoundNodeWavePlayer final : public USoundNodeAssetReferencer
{
public:
	TSoftObjectPtr<class USoundWave>              SoundWaveAssetPtr;                                 // 0x0048(0x0028)(Edit, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	class USoundWave*                             SoundWave;                                         // 0x0070(0x0008)(ZeroConstructor, Transient, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         BitPad_78_0 : 1;                                   // 0x0078(0x0001)(Fixing Bit-Field Size Between Bits [ Dumper-7 ])
	uint8                                         bLooping : 1;                                      // 0x0078(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_79[0x7];                                       // 0x0079(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"SoundNodeWavePlayer">();
	}
	static class USoundNodeWavePlayer* GetDefaultObj()
	{
		return GetDefaultObjImpl<USoundNodeWavePlayer>();
	}
};
static_assert(alignof(USoundNodeWavePlayer) == 0x000008, "Wrong alignment on USoundNodeWavePlayer");
static_assert(sizeof(USoundNodeWavePlayer) == 0x000080, "Wrong size on USoundNodeWavePlayer");
static_assert(offsetof(USoundNodeWavePlayer, SoundWaveAssetPtr) == 0x000048, "Member 'USoundNodeWavePlayer::SoundWaveAssetPtr' has a wrong offset!");
static_assert(offsetof(USoundNodeWavePlayer, SoundWave) == 0x000070, "Member 'USoundNodeWavePlayer::SoundWave' has a wrong offset!");

// Class Engine.SoundSourceBus
// 0x0018 (0x0448 - 0x0430)
class USoundSourceBus final : public USoundWave
{
public:
	ESourceBusChannels                            SourceBusChannels;                                 // 0x0430(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_431[0x3];                                      // 0x0431(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         SourceBusDuration;                                 // 0x0434(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UAudioBus*                              AudioBus;                                          // 0x0438(0x0008)(Edit, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bAutoDeactivateWhenSilent : 1;                     // 0x0440(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_441[0x7];                                      // 0x0441(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"SoundSourceBus">();
	}
	static class USoundSourceBus* GetDefaultObj()
	{
		return GetDefaultObjImpl<USoundSourceBus>();
	}
};
static_assert(alignof(USoundSourceBus) == 0x000008, "Wrong alignment on USoundSourceBus");
static_assert(sizeof(USoundSourceBus) == 0x000448, "Wrong size on USoundSourceBus");
static_assert(offsetof(USoundSourceBus, SourceBusChannels) == 0x000430, "Member 'USoundSourceBus::SourceBusChannels' has a wrong offset!");
static_assert(offsetof(USoundSourceBus, SourceBusDuration) == 0x000434, "Member 'USoundSourceBus::SourceBusDuration' has a wrong offset!");
static_assert(offsetof(USoundSourceBus, AudioBus) == 0x000438, "Member 'USoundSourceBus::AudioBus' has a wrong offset!");

// Class Engine.SoundfieldSubmix
// 0x0028 (0x0070 - 0x0048)
class USoundfieldSubmix final : public USoundSubmixWithParentBase
{
public:
	class FName                                   SoundfieldEncodingFormat;                          // 0x0048(0x0008)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, AssetRegistrySearchable, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class USoundfieldEncodingSettingsBase*        EncodingSettings;                                  // 0x0050(0x0008)(Edit, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TArray<class USoundfieldEffectBase*>          SoundfieldEffectChain;                             // 0x0058(0x0010)(Edit, ZeroConstructor, UObjectWrapper, NativeAccessSpecifierPublic)
	TSubclassOf<class USoundfieldEncodingSettingsBase> EncodingSettingsClass;                        // 0x0068(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"SoundfieldSubmix">();
	}
	static class USoundfieldSubmix* GetDefaultObj()
	{
		return GetDefaultObjImpl<USoundfieldSubmix>();
	}
};
static_assert(alignof(USoundfieldSubmix) == 0x000008, "Wrong alignment on USoundfieldSubmix");
static_assert(sizeof(USoundfieldSubmix) == 0x000070, "Wrong size on USoundfieldSubmix");
static_assert(offsetof(USoundfieldSubmix, SoundfieldEncodingFormat) == 0x000048, "Member 'USoundfieldSubmix::SoundfieldEncodingFormat' has a wrong offset!");
static_assert(offsetof(USoundfieldSubmix, EncodingSettings) == 0x000050, "Member 'USoundfieldSubmix::EncodingSettings' has a wrong offset!");
static_assert(offsetof(USoundfieldSubmix, SoundfieldEffectChain) == 0x000058, "Member 'USoundfieldSubmix::SoundfieldEffectChain' has a wrong offset!");
static_assert(offsetof(USoundfieldSubmix, EncodingSettingsClass) == 0x000068, "Member 'USoundfieldSubmix::EncodingSettingsClass' has a wrong offset!");

// Class Engine.SoundfieldEndpointSubmix
// 0x0038 (0x0078 - 0x0040)
class USoundfieldEndpointSubmix final : public USoundSubmixBase
{
public:
	class FName                                   SoundfieldEndpointType;                            // 0x0040(0x0008)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, AssetRegistrySearchable, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TSubclassOf<class UAudioEndpointSettingsBase> EndpointSettingsClass;                             // 0x0048(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class USoundfieldEndpointSettingsBase*        EndpointSettings;                                  // 0x0050(0x0008)(Edit, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TSubclassOf<class USoundfieldEncodingSettingsBase> EncodingSettingsClass;                        // 0x0058(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class USoundfieldEncodingSettingsBase*        EncodingSettings;                                  // 0x0060(0x0008)(Edit, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TArray<class USoundfieldEffectBase*>          SoundfieldEffectChain;                             // 0x0068(0x0010)(Edit, ZeroConstructor, UObjectWrapper, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"SoundfieldEndpointSubmix">();
	}
	static class USoundfieldEndpointSubmix* GetDefaultObj()
	{
		return GetDefaultObjImpl<USoundfieldEndpointSubmix>();
	}
};
static_assert(alignof(USoundfieldEndpointSubmix) == 0x000008, "Wrong alignment on USoundfieldEndpointSubmix");
static_assert(sizeof(USoundfieldEndpointSubmix) == 0x000078, "Wrong size on USoundfieldEndpointSubmix");
static_assert(offsetof(USoundfieldEndpointSubmix, SoundfieldEndpointType) == 0x000040, "Member 'USoundfieldEndpointSubmix::SoundfieldEndpointType' has a wrong offset!");
static_assert(offsetof(USoundfieldEndpointSubmix, EndpointSettingsClass) == 0x000048, "Member 'USoundfieldEndpointSubmix::EndpointSettingsClass' has a wrong offset!");
static_assert(offsetof(USoundfieldEndpointSubmix, EndpointSettings) == 0x000050, "Member 'USoundfieldEndpointSubmix::EndpointSettings' has a wrong offset!");
static_assert(offsetof(USoundfieldEndpointSubmix, EncodingSettingsClass) == 0x000058, "Member 'USoundfieldEndpointSubmix::EncodingSettingsClass' has a wrong offset!");
static_assert(offsetof(USoundfieldEndpointSubmix, EncodingSettings) == 0x000060, "Member 'USoundfieldEndpointSubmix::EncodingSettings' has a wrong offset!");
static_assert(offsetof(USoundfieldEndpointSubmix, SoundfieldEffectChain) == 0x000068, "Member 'USoundfieldEndpointSubmix::SoundfieldEffectChain' has a wrong offset!");

// Class Engine.WorldPartitionEditorPerProjectUserSettings
// 0x0000 (0x0028 - 0x0028)
class UWorldPartitionEditorPerProjectUserSettings final : public UObject
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"WorldPartitionEditorPerProjectUserSettings">();
	}
	static class UWorldPartitionEditorPerProjectUserSettings* GetDefaultObj()
	{
		return GetDefaultObjImpl<UWorldPartitionEditorPerProjectUserSettings>();
	}
};
static_assert(alignof(UWorldPartitionEditorPerProjectUserSettings) == 0x000008, "Wrong alignment on UWorldPartitionEditorPerProjectUserSettings");
static_assert(sizeof(UWorldPartitionEditorPerProjectUserSettings) == 0x000028, "Wrong size on UWorldPartitionEditorPerProjectUserSettings");

// Class Engine.SpectatorPawn
// 0x0000 (0x0350 - 0x0350)
class ASpectatorPawn final : public ADefaultPawn
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"SpectatorPawn">();
	}
	static class ASpectatorPawn* GetDefaultObj()
	{
		return GetDefaultObjImpl<ASpectatorPawn>();
	}
};
static_assert(alignof(ASpectatorPawn) == 0x000008, "Wrong alignment on ASpectatorPawn");
static_assert(sizeof(ASpectatorPawn) == 0x000350, "Wrong size on ASpectatorPawn");

// Class Engine.SpectatorPawnMovement
// 0x0008 (0x0180 - 0x0178)
class USpectatorPawnMovement final : public UFloatingPawnMovement
{
public:
	uint8                                         bIgnoreTimeDilation : 1;                           // 0x0178(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_179[0x7];                                      // 0x0179(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"SpectatorPawnMovement">();
	}
	static class USpectatorPawnMovement* GetDefaultObj()
	{
		return GetDefaultObjImpl<USpectatorPawnMovement>();
	}
};
static_assert(alignof(USpectatorPawnMovement) == 0x000008, "Wrong alignment on USpectatorPawnMovement");
static_assert(sizeof(USpectatorPawnMovement) == 0x000180, "Wrong size on USpectatorPawnMovement");

// Class Engine.StaticMesh
// 0x0188 (0x0250 - 0x00C8)
class UStaticMesh final : public UStreamableRenderAsset
{
public:
	uint8                                         Pad_C8[0x20];                                      // 0x00C8(0x0020)(Fixing Size After Last Property [ Dumper-7 ])
	struct FPerQualityLevelInt                    MinQualityLevelLOD;                                // 0x00E8(0x0068)(NativeAccessSpecifierPublic)
	struct FPerPlatformInt                        MinLOD;                                            // 0x0150(0x0004)(NoDestructor, NativeAccessSpecifierPublic)
	uint8                                         Pad_154[0x4];                                      // 0x0154(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<struct FStaticMaterial>                StaticMaterials;                                   // 0x0158(0x0010)(BlueprintVisible, ZeroConstructor, NativeAccessSpecifierPrivate)
	float                                         LightmapUVDensity;                                 // 0x0168(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	int32                                         LightMapResolution;                                // 0x016C(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         LightMapCoordinateIndex;                           // 0x0170(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         DistanceFieldSelfShadowBias;                       // 0x0174(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UBodySetup*                             BodySetup;                                         // 0x0178(0x0008)(Edit, ExportObject, ZeroConstructor, Transient, InstancedReference, DuplicateTransient, NoDestructor, PersistentInstance, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	int32                                         LODForCollision;                                   // 0x0180(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bGenerateMeshDistanceField : 1;                    // 0x0184(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bStripComplexCollisionForConsole : 1;              // 0x0184(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Deprecated, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bHasNavigationData : 1;                            // 0x0184(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bSupportUniformlyDistributedSampling : 1;          // 0x0184(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (Edit, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bSupportPhysicalMaterialMasks : 1;                 // 0x0184(0x0001)(BitIndex: 0x04, PropSize: 0x0001 (Edit, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bSupportRayTracing : 1;                            // 0x0184(0x0001)(BitIndex: 0x05, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bDoFastBuild : 1;                                  // 0x0184(0x0001)(BitIndex: 0x06, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bIsBuiltAtRuntime : 1;                             // 0x0184(0x0001)(BitIndex: 0x07, PropSize: 0x0001 (Deprecated, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate))
	uint8                                         BitPad_185_0 : 1;                                  // 0x0185(0x0001)(Fixing Bit-Field Size Between Bits [ Dumper-7 ])
	uint8                                         bAllowCPUAccess : 1;                               // 0x0185(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bSupportGpuUniformlyDistributedSampling : 1;       // 0x0185(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Edit, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_186[0x22];                                     // 0x0186(0x0022)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<class UStaticMeshSocket*>              Sockets;                                           // 0x01A8(0x0010)(ZeroConstructor, UObjectWrapper, NativeAccessSpecifierPublic)
	uint8                                         Pad_1B8[0x10];                                     // 0x01B8(0x0010)(Fixing Size After Last Property [ Dumper-7 ])
	struct FVector                                PositiveBoundsExtension;                           // 0x01C8(0x0018)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector                                NegativeBoundsExtension;                           // 0x01E0(0x0018)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FBoxSphereBounds                       ExtendedBounds;                                    // 0x01F8(0x0038)(ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
	int32                                         ElementToIgnoreForTexFactor;                       // 0x0230(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_234[0x4];                                      // 0x0234(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<class UAssetUserData*>                 AssetUserData;                                     // 0x0238(0x0010)(Edit, ExportObject, ZeroConstructor, ContainsInstancedReference, AdvancedDisplay, Protected, UObjectWrapper, NativeAccessSpecifierProtected)
	class UNavCollisionBase*                      NavCollision;                                      // 0x0248(0x0008)(Edit, ExportObject, ZeroConstructor, Transient, EditConst, InstancedReference, DuplicateTransient, NoDestructor, PersistentInstance, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)

public:
	static class UStaticMeshDescription* CreateStaticMeshDescription(class UObject* Outer_0);

	class FName AddMaterial(class UMaterialInterface* Material);
	void AddSocket(class UStaticMeshSocket* Socket);
	void BuildFromStaticMeshDescriptions(const TArray<class UStaticMeshDescription*>& StaticMeshDescriptions, bool bBuildSimpleCollision, bool bFastBuild);
	class UStaticMeshDescription* GetStaticMeshDescription(int32 LODIndex);
	void RemoveSocket(class UStaticMeshSocket* Socket);
	void SetMinimumLODForPlatform(const class FName& PlatformName, int32 InMinLOD);
	void SetMinimumLODForPlatforms(const TMap<class FName, int32>& PlatformMinimumLODs);
	void SetMinLODForQualityLevels(const TMap<EPerQualityLevels, int32>& QualityLevelMinimumLODs, int32 Default);
	void SetStaticMaterials(const TArray<struct FStaticMaterial>& InStaticMaterials);

	class UStaticMeshSocket* FindSocket(class FName InSocketName) const;
	struct FBox GetBoundingBox() const;
	struct FBoxSphereBounds GetBounds() const;
	class UMaterialInterface* GetMaterial(int32 MaterialIndex) const;
	int32 GetMaterialIndex(class FName MaterialSlotName) const;
	int32 GetMinimumLODForPlatform(const class FName& PlatformName) const;
	void GetMinimumLODForPlatforms(TMap<class FName, int32>* PlatformMinimumLODs) const;
	int32 GetMinimumLODForQualityLevel(const class FName& QualityLevel) const;
	void GetMinimumLODForQualityLevels(TMap<class FName, int32>* QualityLevelMinimumLODs) const;
	void GetMinLODForQualityLevels(TMap<EPerQualityLevels, int32>* QualityLevelMinimumLODs, int32* Default) const;
	int32 GetNumLODs() const;
	int32 GetNumSections(int32 InLOD) const;
	int32 GetNumTriangles(int32 LODIndex) const;
	TArray<class UStaticMeshSocket*> GetSocketsByTag(const class FString& InSocketTag) const;
	const TArray<struct FStaticMaterial> GetStaticMaterials() const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"StaticMesh">();
	}
	static class UStaticMesh* GetDefaultObj()
	{
		return GetDefaultObjImpl<UStaticMesh>();
	}
};
static_assert(alignof(UStaticMesh) == 0x000008, "Wrong alignment on UStaticMesh");
static_assert(sizeof(UStaticMesh) == 0x000250, "Wrong size on UStaticMesh");
static_assert(offsetof(UStaticMesh, MinQualityLevelLOD) == 0x0000E8, "Member 'UStaticMesh::MinQualityLevelLOD' has a wrong offset!");
static_assert(offsetof(UStaticMesh, MinLOD) == 0x000150, "Member 'UStaticMesh::MinLOD' has a wrong offset!");
static_assert(offsetof(UStaticMesh, StaticMaterials) == 0x000158, "Member 'UStaticMesh::StaticMaterials' has a wrong offset!");
static_assert(offsetof(UStaticMesh, LightmapUVDensity) == 0x000168, "Member 'UStaticMesh::LightmapUVDensity' has a wrong offset!");
static_assert(offsetof(UStaticMesh, LightMapResolution) == 0x00016C, "Member 'UStaticMesh::LightMapResolution' has a wrong offset!");
static_assert(offsetof(UStaticMesh, LightMapCoordinateIndex) == 0x000170, "Member 'UStaticMesh::LightMapCoordinateIndex' has a wrong offset!");
static_assert(offsetof(UStaticMesh, DistanceFieldSelfShadowBias) == 0x000174, "Member 'UStaticMesh::DistanceFieldSelfShadowBias' has a wrong offset!");
static_assert(offsetof(UStaticMesh, BodySetup) == 0x000178, "Member 'UStaticMesh::BodySetup' has a wrong offset!");
static_assert(offsetof(UStaticMesh, LODForCollision) == 0x000180, "Member 'UStaticMesh::LODForCollision' has a wrong offset!");
static_assert(offsetof(UStaticMesh, Sockets) == 0x0001A8, "Member 'UStaticMesh::Sockets' has a wrong offset!");
static_assert(offsetof(UStaticMesh, PositiveBoundsExtension) == 0x0001C8, "Member 'UStaticMesh::PositiveBoundsExtension' has a wrong offset!");
static_assert(offsetof(UStaticMesh, NegativeBoundsExtension) == 0x0001E0, "Member 'UStaticMesh::NegativeBoundsExtension' has a wrong offset!");
static_assert(offsetof(UStaticMesh, ExtendedBounds) == 0x0001F8, "Member 'UStaticMesh::ExtendedBounds' has a wrong offset!");
static_assert(offsetof(UStaticMesh, ElementToIgnoreForTexFactor) == 0x000230, "Member 'UStaticMesh::ElementToIgnoreForTexFactor' has a wrong offset!");
static_assert(offsetof(UStaticMesh, AssetUserData) == 0x000238, "Member 'UStaticMesh::AssetUserData' has a wrong offset!");
static_assert(offsetof(UStaticMesh, NavCollision) == 0x000248, "Member 'UStaticMesh::NavCollision' has a wrong offset!");

// Class Engine.StaticMeshDescriptionBulkData
// 0x0000 (0x0028 - 0x0028)
class UStaticMeshDescriptionBulkData final : public UMeshDescriptionBaseBulkData
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"StaticMeshDescriptionBulkData">();
	}
	static class UStaticMeshDescriptionBulkData* GetDefaultObj()
	{
		return GetDefaultObjImpl<UStaticMeshDescriptionBulkData>();
	}
};
static_assert(alignof(UStaticMeshDescriptionBulkData) == 0x000008, "Wrong alignment on UStaticMeshDescriptionBulkData");
static_assert(sizeof(UStaticMeshDescriptionBulkData) == 0x000028, "Wrong size on UStaticMeshDescriptionBulkData");

// Class Engine.StereoLayerFunctionLibrary
// 0x0000 (0x0028 - 0x0028)
class UStereoLayerFunctionLibrary final : public UBlueprintFunctionLibrary
{
public:
	static void EnableAutoLoadingSplashScreen(bool InAutoShowEnabled);
	static void HideSplashScreen();
	static void SetSplashScreen(class UTexture* Texture, const struct FVector2D& Scale, const struct FVector& Offset, bool bShowLoadingMovie, bool bShowOnSet);
	static void ShowSplashScreen();

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"StereoLayerFunctionLibrary">();
	}
	static class UStereoLayerFunctionLibrary* GetDefaultObj()
	{
		return GetDefaultObjImpl<UStereoLayerFunctionLibrary>();
	}
};
static_assert(alignof(UStereoLayerFunctionLibrary) == 0x000008, "Wrong alignment on UStereoLayerFunctionLibrary");
static_assert(sizeof(UStereoLayerFunctionLibrary) == 0x000028, "Wrong size on UStereoLayerFunctionLibrary");

// Class Engine.ServerStreamingLevelsVisibility
// 0x0050 (0x02F0 - 0x02A0)
class AServerStreamingLevelsVisibility final : public AActor
{
public:
	uint8                                         Pad_2A0[0x50];                                     // 0x02A0(0x0050)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ServerStreamingLevelsVisibility">();
	}
	static class AServerStreamingLevelsVisibility* GetDefaultObj()
	{
		return GetDefaultObjImpl<AServerStreamingLevelsVisibility>();
	}
};
static_assert(alignof(AServerStreamingLevelsVisibility) == 0x000008, "Wrong alignment on AServerStreamingLevelsVisibility");
static_assert(sizeof(AServerStreamingLevelsVisibility) == 0x0002F0, "Wrong size on AServerStreamingLevelsVisibility");

// Class Engine.AudioSubsystemCollectionRoot
// 0x0008 (0x0030 - 0x0028)
class UAudioSubsystemCollectionRoot final : public UObject
{
public:
	uint8                                         Pad_28[0x8];                                       // 0x0028(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AudioSubsystemCollectionRoot">();
	}
	static class UAudioSubsystemCollectionRoot* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAudioSubsystemCollectionRoot>();
	}
};
static_assert(alignof(UAudioSubsystemCollectionRoot) == 0x000008, "Wrong alignment on UAudioSubsystemCollectionRoot");
static_assert(sizeof(UAudioSubsystemCollectionRoot) == 0x000030, "Wrong size on UAudioSubsystemCollectionRoot");

// Class Engine.LocalPlayerSubsystem
// 0x0000 (0x0030 - 0x0030)
class ULocalPlayerSubsystem : public USubsystem
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"LocalPlayerSubsystem">();
	}
	static class ULocalPlayerSubsystem* GetDefaultObj()
	{
		return GetDefaultObjImpl<ULocalPlayerSubsystem>();
	}
};
static_assert(alignof(ULocalPlayerSubsystem) == 0x000008, "Wrong alignment on ULocalPlayerSubsystem");
static_assert(sizeof(ULocalPlayerSubsystem) == 0x000030, "Wrong size on ULocalPlayerSubsystem");

// Class Engine.TargetPoint
// 0x0000 (0x02A0 - 0x02A0)
class ATargetPoint final : public AActor
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"TargetPoint">();
	}
	static class ATargetPoint* GetDefaultObj()
	{
		return GetDefaultObjImpl<ATargetPoint>();
	}
};
static_assert(alignof(ATargetPoint) == 0x000008, "Wrong alignment on ATargetPoint");
static_assert(sizeof(ATargetPoint) == 0x0002A0, "Wrong size on ATargetPoint");

// Class Engine.AutomationTestSettings
// 0x0330 (0x0358 - 0x0028)
class UAutomationTestSettings final : public UObject
{
public:
	TArray<class FString>                         EngineTestModules;                                 // 0x0028(0x0010)(Edit, ZeroConstructor, Config, NativeAccessSpecifierPublic)
	TArray<class FString>                         EditorTestModules;                                 // 0x0038(0x0010)(Edit, ZeroConstructor, Config, NativeAccessSpecifierPublic)
	struct FSoftObjectPath                        AutomationTestmap;                                 // 0x0048(0x0020)(Edit, ZeroConstructor, Config, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TArray<struct FEditorMapPerformanceTestDefinition> EditorPerformanceTestMaps;                    // 0x0068(0x0010)(Edit, ZeroConstructor, Config, NativeAccessSpecifierPublic)
	TArray<class FString>                         AssetsToOpen;                                      // 0x0078(0x0010)(Edit, ZeroConstructor, Config, NativeAccessSpecifierPublic)
	TArray<class FString>                         MapsToPIETest;                                     // 0x0088(0x0010)(Edit, ZeroConstructor, Config, NativeAccessSpecifierPublic)
	bool                                          bUseAllProjectMapsToPlayInPIE;                     // 0x0098(0x0001)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_99[0x7];                                       // 0x0099(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	struct FBuildPromotionTestSettings            BuildPromotionTest;                                // 0x00A0(0x01F0)(Edit, Config, NativeAccessSpecifierPublic)
	struct FMaterialEditorPromotionSettings       MaterialEditorPromotionTest;                       // 0x0290(0x0030)(Edit, Config, NativeAccessSpecifierPublic)
	struct FParticleEditorPromotionSettings       ParticleEditorPromotionTest;                       // 0x02C0(0x0010)(Edit, Config, NativeAccessSpecifierPublic)
	struct FBlueprintEditorPromotionSettings      BlueprintEditorPromotionTest;                      // 0x02D0(0x0030)(Edit, Config, NativeAccessSpecifierPublic)
	TArray<class FString>                         TestLevelFolders;                                  // 0x0300(0x0010)(Edit, ZeroConstructor, Config, NativeAccessSpecifierPublic)
	TArray<struct FExternalToolDefinition>        ExternalTools;                                     // 0x0310(0x0010)(Edit, ZeroConstructor, Config, NativeAccessSpecifierPublic)
	TArray<struct FEditorImportExportTestDefinition> ImportExportTestDefinitions;                    // 0x0320(0x0010)(Edit, ZeroConstructor, Config, NativeAccessSpecifierPublic)
	TArray<struct FLaunchOnTestSettings>          LaunchOnSettings;                                  // 0x0330(0x0010)(Edit, ZeroConstructor, Config, NativeAccessSpecifierPublic)
	struct FIntPoint                              DefaultScreenshotResolution;                       // 0x0340(0x0008)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         PIETestDuration;                                   // 0x0348(0x0004)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         DefaultInteractiveFramerate;                       // 0x034C(0x0004)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         DefaultInteractiveFramerateWaitTime;               // 0x0350(0x0004)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         DefaultInteractiveFramerateDuration;               // 0x0354(0x0004)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AutomationTestSettings">();
	}
	static class UAutomationTestSettings* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAutomationTestSettings>();
	}
};
static_assert(alignof(UAutomationTestSettings) == 0x000008, "Wrong alignment on UAutomationTestSettings");
static_assert(sizeof(UAutomationTestSettings) == 0x000358, "Wrong size on UAutomationTestSettings");
static_assert(offsetof(UAutomationTestSettings, EngineTestModules) == 0x000028, "Member 'UAutomationTestSettings::EngineTestModules' has a wrong offset!");
static_assert(offsetof(UAutomationTestSettings, EditorTestModules) == 0x000038, "Member 'UAutomationTestSettings::EditorTestModules' has a wrong offset!");
static_assert(offsetof(UAutomationTestSettings, AutomationTestmap) == 0x000048, "Member 'UAutomationTestSettings::AutomationTestmap' has a wrong offset!");
static_assert(offsetof(UAutomationTestSettings, EditorPerformanceTestMaps) == 0x000068, "Member 'UAutomationTestSettings::EditorPerformanceTestMaps' has a wrong offset!");
static_assert(offsetof(UAutomationTestSettings, AssetsToOpen) == 0x000078, "Member 'UAutomationTestSettings::AssetsToOpen' has a wrong offset!");
static_assert(offsetof(UAutomationTestSettings, MapsToPIETest) == 0x000088, "Member 'UAutomationTestSettings::MapsToPIETest' has a wrong offset!");
static_assert(offsetof(UAutomationTestSettings, bUseAllProjectMapsToPlayInPIE) == 0x000098, "Member 'UAutomationTestSettings::bUseAllProjectMapsToPlayInPIE' has a wrong offset!");
static_assert(offsetof(UAutomationTestSettings, BuildPromotionTest) == 0x0000A0, "Member 'UAutomationTestSettings::BuildPromotionTest' has a wrong offset!");
static_assert(offsetof(UAutomationTestSettings, MaterialEditorPromotionTest) == 0x000290, "Member 'UAutomationTestSettings::MaterialEditorPromotionTest' has a wrong offset!");
static_assert(offsetof(UAutomationTestSettings, ParticleEditorPromotionTest) == 0x0002C0, "Member 'UAutomationTestSettings::ParticleEditorPromotionTest' has a wrong offset!");
static_assert(offsetof(UAutomationTestSettings, BlueprintEditorPromotionTest) == 0x0002D0, "Member 'UAutomationTestSettings::BlueprintEditorPromotionTest' has a wrong offset!");
static_assert(offsetof(UAutomationTestSettings, TestLevelFolders) == 0x000300, "Member 'UAutomationTestSettings::TestLevelFolders' has a wrong offset!");
static_assert(offsetof(UAutomationTestSettings, ExternalTools) == 0x000310, "Member 'UAutomationTestSettings::ExternalTools' has a wrong offset!");
static_assert(offsetof(UAutomationTestSettings, ImportExportTestDefinitions) == 0x000320, "Member 'UAutomationTestSettings::ImportExportTestDefinitions' has a wrong offset!");
static_assert(offsetof(UAutomationTestSettings, LaunchOnSettings) == 0x000330, "Member 'UAutomationTestSettings::LaunchOnSettings' has a wrong offset!");
static_assert(offsetof(UAutomationTestSettings, DefaultScreenshotResolution) == 0x000340, "Member 'UAutomationTestSettings::DefaultScreenshotResolution' has a wrong offset!");
static_assert(offsetof(UAutomationTestSettings, PIETestDuration) == 0x000348, "Member 'UAutomationTestSettings::PIETestDuration' has a wrong offset!");
static_assert(offsetof(UAutomationTestSettings, DefaultInteractiveFramerate) == 0x00034C, "Member 'UAutomationTestSettings::DefaultInteractiveFramerate' has a wrong offset!");
static_assert(offsetof(UAutomationTestSettings, DefaultInteractiveFramerateWaitTime) == 0x000350, "Member 'UAutomationTestSettings::DefaultInteractiveFramerateWaitTime' has a wrong offset!");
static_assert(offsetof(UAutomationTestSettings, DefaultInteractiveFramerateDuration) == 0x000354, "Member 'UAutomationTestSettings::DefaultInteractiveFramerateDuration' has a wrong offset!");

// Class Engine.TransactionDiffingTestObject
// 0x0070 (0x0098 - 0x0028)
class UTransactionDiffingTestObject final : public UObject
{
public:
	TArray<class FName>                           NamesArray;                                        // 0x0028(0x0010)(ZeroConstructor, NativeAccessSpecifierPublic)
	class FName                                   AdditionalName;                                    // 0x0038(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TArray<class UObject*>                        ObjectsArray;                                      // 0x0040(0x0010)(ZeroConstructor, UObjectWrapper, NativeAccessSpecifierPublic)
	class UObject*                                AdditionalObject;                                  // 0x0050(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TArray<TSoftObjectPtr<class UObject>>         SoftObjectsArray;                                  // 0x0058(0x0010)(ZeroConstructor, UObjectWrapper, NativeAccessSpecifierPublic)
	TSoftObjectPtr<class UObject>                 AdditionalSoftObject;                              // 0x0068(0x0028)(UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         PropertyData;                                      // 0x0090(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_94[0x4];                                       // 0x0094(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"TransactionDiffingTestObject">();
	}
	static class UTransactionDiffingTestObject* GetDefaultObj()
	{
		return GetDefaultObjImpl<UTransactionDiffingTestObject>();
	}
};
static_assert(alignof(UTransactionDiffingTestObject) == 0x000008, "Wrong alignment on UTransactionDiffingTestObject");
static_assert(sizeof(UTransactionDiffingTestObject) == 0x000098, "Wrong size on UTransactionDiffingTestObject");
static_assert(offsetof(UTransactionDiffingTestObject, NamesArray) == 0x000028, "Member 'UTransactionDiffingTestObject::NamesArray' has a wrong offset!");
static_assert(offsetof(UTransactionDiffingTestObject, AdditionalName) == 0x000038, "Member 'UTransactionDiffingTestObject::AdditionalName' has a wrong offset!");
static_assert(offsetof(UTransactionDiffingTestObject, ObjectsArray) == 0x000040, "Member 'UTransactionDiffingTestObject::ObjectsArray' has a wrong offset!");
static_assert(offsetof(UTransactionDiffingTestObject, AdditionalObject) == 0x000050, "Member 'UTransactionDiffingTestObject::AdditionalObject' has a wrong offset!");
static_assert(offsetof(UTransactionDiffingTestObject, SoftObjectsArray) == 0x000058, "Member 'UTransactionDiffingTestObject::SoftObjectsArray' has a wrong offset!");
static_assert(offsetof(UTransactionDiffingTestObject, AdditionalSoftObject) == 0x000068, "Member 'UTransactionDiffingTestObject::AdditionalSoftObject' has a wrong offset!");
static_assert(offsetof(UTransactionDiffingTestObject, PropertyData) == 0x000090, "Member 'UTransactionDiffingTestObject::PropertyData' has a wrong offset!");

// Class Engine.TextureCube
// 0x0090 (0x0260 - 0x01D0)
class UTextureCube final : public UTexture
{
public:
	uint8                                         Pad_1C8[0x98];                                     // 0x01C8(0x0098)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"TextureCube">();
	}
	static class UTextureCube* GetDefaultObj()
	{
		return GetDefaultObjImpl<UTextureCube>();
	}
};
static_assert(alignof(UTextureCube) == 0x000010, "Wrong alignment on UTextureCube");
static_assert(sizeof(UTextureCube) == 0x000260, "Wrong size on UTextureCube");

// Class Engine.TextureCubeArray
// 0x0090 (0x0260 - 0x01D0)
class UTextureCubeArray final : public UTexture
{
public:
	uint8                                         Pad_1C8[0x98];                                     // 0x01C8(0x0098)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"TextureCubeArray">();
	}
	static class UTextureCubeArray* GetDefaultObj()
	{
		return GetDefaultObjImpl<UTextureCubeArray>();
	}
};
static_assert(alignof(UTextureCubeArray) == 0x000010, "Wrong alignment on UTextureCubeArray");
static_assert(sizeof(UTextureCubeArray) == 0x000260, "Wrong size on UTextureCubeArray");

// Class Engine.TextureLightProfile
// 0x0000 (0x0280 - 0x0280)
class UTextureLightProfile final : public UTexture2D
{
public:
	float                                         Brightness;                                        // 0x0278(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, AssetRegistrySearchable, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         TextureMultiplier;                                 // 0x027C(0x0004)(Edit, ZeroConstructor, EditConst, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"TextureLightProfile">();
	}
	static class UTextureLightProfile* GetDefaultObj()
	{
		return GetDefaultObjImpl<UTextureLightProfile>();
	}
};
static_assert(alignof(UTextureLightProfile) == 0x000010, "Wrong alignment on UTextureLightProfile");
static_assert(sizeof(UTextureLightProfile) == 0x000280, "Wrong size on UTextureLightProfile");
static_assert(offsetof(UTextureLightProfile, Brightness) == 0x000278, "Member 'UTextureLightProfile::Brightness' has a wrong offset!");
static_assert(offsetof(UTextureLightProfile, TextureMultiplier) == 0x00027C, "Member 'UTextureLightProfile::TextureMultiplier' has a wrong offset!");

// Class Engine.TextureRenderTargetCube
// 0x0020 (0x01F0 - 0x01D0)
class UTextureRenderTargetCube final : public UTextureRenderTarget
{
public:
	int32                                         SizeX;                                             // 0x01D0(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, AssetRegistrySearchable, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FLinearColor                           ClearColor;                                        // 0x01D4(0x0010)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EPixelFormat                                  OverrideFormat;                                    // 0x01E4(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bHDR : 1;                                          // 0x01E5(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, AssetRegistrySearchable, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bForceLinearGamma : 1;                             // 0x01E5(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_1E6[0xA];                                      // 0x01E6(0x000A)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"TextureRenderTargetCube">();
	}
	static class UTextureRenderTargetCube* GetDefaultObj()
	{
		return GetDefaultObjImpl<UTextureRenderTargetCube>();
	}
};
static_assert(alignof(UTextureRenderTargetCube) == 0x000010, "Wrong alignment on UTextureRenderTargetCube");
static_assert(sizeof(UTextureRenderTargetCube) == 0x0001F0, "Wrong size on UTextureRenderTargetCube");
static_assert(offsetof(UTextureRenderTargetCube, SizeX) == 0x0001D0, "Member 'UTextureRenderTargetCube::SizeX' has a wrong offset!");
static_assert(offsetof(UTextureRenderTargetCube, ClearColor) == 0x0001D4, "Member 'UTextureRenderTargetCube::ClearColor' has a wrong offset!");
static_assert(offsetof(UTextureRenderTargetCube, OverrideFormat) == 0x0001E4, "Member 'UTextureRenderTargetCube::OverrideFormat' has a wrong offset!");

// Class Engine.TextureRenderTargetVolume
// 0x0020 (0x01F0 - 0x01D0)
class UTextureRenderTargetVolume final : public UTextureRenderTarget
{
public:
	int32                                         SizeX;                                             // 0x01D0(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, AssetRegistrySearchable, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         SizeY;                                             // 0x01D4(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, AssetRegistrySearchable, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         SizeZ;                                             // 0x01D8(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, AssetRegistrySearchable, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FLinearColor                           ClearColor;                                        // 0x01DC(0x0010)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EPixelFormat                                  OverrideFormat;                                    // 0x01EC(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bHDR : 1;                                          // 0x01ED(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, BlueprintVisible, BlueprintReadOnly, NoDestructor, AssetRegistrySearchable, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bForceLinearGamma : 1;                             // 0x01ED(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_1EE[0x2];                                      // 0x01EE(0x0002)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"TextureRenderTargetVolume">();
	}
	static class UTextureRenderTargetVolume* GetDefaultObj()
	{
		return GetDefaultObjImpl<UTextureRenderTargetVolume>();
	}
};
static_assert(alignof(UTextureRenderTargetVolume) == 0x000010, "Wrong alignment on UTextureRenderTargetVolume");
static_assert(sizeof(UTextureRenderTargetVolume) == 0x0001F0, "Wrong size on UTextureRenderTargetVolume");
static_assert(offsetof(UTextureRenderTargetVolume, SizeX) == 0x0001D0, "Member 'UTextureRenderTargetVolume::SizeX' has a wrong offset!");
static_assert(offsetof(UTextureRenderTargetVolume, SizeY) == 0x0001D4, "Member 'UTextureRenderTargetVolume::SizeY' has a wrong offset!");
static_assert(offsetof(UTextureRenderTargetVolume, SizeZ) == 0x0001D8, "Member 'UTextureRenderTargetVolume::SizeZ' has a wrong offset!");
static_assert(offsetof(UTextureRenderTargetVolume, ClearColor) == 0x0001DC, "Member 'UTextureRenderTargetVolume::ClearColor' has a wrong offset!");
static_assert(offsetof(UTextureRenderTargetVolume, OverrideFormat) == 0x0001EC, "Member 'UTextureRenderTargetVolume::OverrideFormat' has a wrong offset!");

// Class Engine.TimelineTemplate
// 0x0090 (0x00B8 - 0x0028)
class UTimelineTemplate final : public UObject
{
public:
	float                                         TimelineLength;                                    // 0x0028(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	ETimelineLengthMode                           LengthMode;                                        // 0x002C(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bAutoPlay : 1;                                     // 0x002D(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bLoop : 1;                                         // 0x002D(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bReplicated : 1;                                   // 0x002D(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bIgnoreTimeDilation : 1;                           // 0x002D(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_2E[0x2];                                       // 0x002E(0x0002)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<struct FTTEventTrack>                  EventTracks;                                       // 0x0030(0x0010)(ZeroConstructor, NativeAccessSpecifierPublic)
	TArray<struct FTTFloatTrack>                  FloatTracks;                                       // 0x0040(0x0010)(ZeroConstructor, NativeAccessSpecifierPublic)
	TArray<struct FTTVectorTrack>                 VectorTracks;                                      // 0x0050(0x0010)(ZeroConstructor, NativeAccessSpecifierPublic)
	TArray<struct FTTLinearColorTrack>            LinearColorTracks;                                 // 0x0060(0x0010)(ZeroConstructor, NativeAccessSpecifierPublic)
	TArray<struct FBPVariableMetaDataEntry>       MetaDataArray;                                     // 0x0070(0x0010)(Edit, ZeroConstructor, NativeAccessSpecifierPublic)
	struct FGuid                                  TimelineGuid;                                      // 0x0080(0x0010)(ZeroConstructor, DuplicateTransient, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	ETickingGroup                                 TimelineTickGroup;                                 // 0x0090(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_91[0x3];                                       // 0x0091(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	class FName                                   VariableName;                                      // 0x0094(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	class FName                                   DirectionPropertyName;                             // 0x009C(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	class FName                                   UpdateFunctionName;                                // 0x00A4(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	class FName                                   FinishedFunctionName;                              // 0x00AC(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_B4[0x4];                                       // 0x00B4(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"TimelineTemplate">();
	}
	static class UTimelineTemplate* GetDefaultObj()
	{
		return GetDefaultObjImpl<UTimelineTemplate>();
	}
};
static_assert(alignof(UTimelineTemplate) == 0x000008, "Wrong alignment on UTimelineTemplate");
static_assert(sizeof(UTimelineTemplate) == 0x0000B8, "Wrong size on UTimelineTemplate");
static_assert(offsetof(UTimelineTemplate, TimelineLength) == 0x000028, "Member 'UTimelineTemplate::TimelineLength' has a wrong offset!");
static_assert(offsetof(UTimelineTemplate, LengthMode) == 0x00002C, "Member 'UTimelineTemplate::LengthMode' has a wrong offset!");
static_assert(offsetof(UTimelineTemplate, EventTracks) == 0x000030, "Member 'UTimelineTemplate::EventTracks' has a wrong offset!");
static_assert(offsetof(UTimelineTemplate, FloatTracks) == 0x000040, "Member 'UTimelineTemplate::FloatTracks' has a wrong offset!");
static_assert(offsetof(UTimelineTemplate, VectorTracks) == 0x000050, "Member 'UTimelineTemplate::VectorTracks' has a wrong offset!");
static_assert(offsetof(UTimelineTemplate, LinearColorTracks) == 0x000060, "Member 'UTimelineTemplate::LinearColorTracks' has a wrong offset!");
static_assert(offsetof(UTimelineTemplate, MetaDataArray) == 0x000070, "Member 'UTimelineTemplate::MetaDataArray' has a wrong offset!");
static_assert(offsetof(UTimelineTemplate, TimelineGuid) == 0x000080, "Member 'UTimelineTemplate::TimelineGuid' has a wrong offset!");
static_assert(offsetof(UTimelineTemplate, TimelineTickGroup) == 0x000090, "Member 'UTimelineTemplate::TimelineTickGroup' has a wrong offset!");
static_assert(offsetof(UTimelineTemplate, VariableName) == 0x000094, "Member 'UTimelineTemplate::VariableName' has a wrong offset!");
static_assert(offsetof(UTimelineTemplate, DirectionPropertyName) == 0x00009C, "Member 'UTimelineTemplate::DirectionPropertyName' has a wrong offset!");
static_assert(offsetof(UTimelineTemplate, UpdateFunctionName) == 0x0000A4, "Member 'UTimelineTemplate::UpdateFunctionName' has a wrong offset!");
static_assert(offsetof(UTimelineTemplate, FinishedFunctionName) == 0x0000AC, "Member 'UTimelineTemplate::FinishedFunctionName' has a wrong offset!");

// Class Engine.UserDefinedEnum
// 0x0050 (0x00B8 - 0x0068)
class UUserDefinedEnum final : public UEnum
{
public:
	TMap<class FName, class FText>                DisplayNameMap;                                    // 0x0068(0x0050)(NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"UserDefinedEnum">();
	}
	static class UUserDefinedEnum* GetDefaultObj()
	{
		return GetDefaultObjImpl<UUserDefinedEnum>();
	}
};
static_assert(alignof(UUserDefinedEnum) == 0x000008, "Wrong alignment on UUserDefinedEnum");
static_assert(sizeof(UUserDefinedEnum) == 0x0000B8, "Wrong size on UUserDefinedEnum");
static_assert(offsetof(UUserDefinedEnum, DisplayNameMap) == 0x000068, "Member 'UUserDefinedEnum::DisplayNameMap' has a wrong offset!");

// Class Engine.UserInterfaceSettings
// 0x0278 (0x02B0 - 0x0038)
class UUserInterfaceSettings final : public UDeveloperSettings
{
public:
	ERenderFocusRule                              RenderFocusRule;                                   // 0x0038(0x0001)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_39[0x7];                                       // 0x0039(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	TMap<EMouseCursor, struct FHardwareCursorReference> HardwareCursors;                             // 0x0040(0x0050)(Edit, Config, NativeAccessSpecifierPublic)
	TMap<EMouseCursor, struct FSoftClassPath>     SoftwareCursors;                                   // 0x0090(0x0050)(Edit, Config, NativeAccessSpecifierPublic)
	struct FSoftClassPath                         DefaultCursor;                                     // 0x00E0(0x0020)(ZeroConstructor, Config, Deprecated, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FSoftClassPath                         TextEditBeamCursor;                                // 0x0100(0x0020)(ZeroConstructor, Config, Deprecated, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FSoftClassPath                         CrosshairsCursor;                                  // 0x0120(0x0020)(ZeroConstructor, Config, Deprecated, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FSoftClassPath                         HandCursor;                                        // 0x0140(0x0020)(ZeroConstructor, Config, Deprecated, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FSoftClassPath                         GrabHandCursor;                                    // 0x0160(0x0020)(ZeroConstructor, Config, Deprecated, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FSoftClassPath                         GrabHandClosedCursor;                              // 0x0180(0x0020)(ZeroConstructor, Config, Deprecated, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FSoftClassPath                         SlashedCircleCursor;                               // 0x01A0(0x0020)(ZeroConstructor, Config, Deprecated, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         ApplicationScale;                                  // 0x01C0(0x0004)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EUIScalingRule                                UIScaleRule;                                       // 0x01C4(0x0001)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1C5[0x3];                                      // 0x01C5(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	struct FSoftClassPath                         CustomScalingRuleClass;                            // 0x01C8(0x0020)(Edit, ZeroConstructor, Config, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FRuntimeFloatCurve                     UIScaleCurve;                                      // 0x01E8(0x0088)(Edit, Config, NativeAccessSpecifierPublic)
	bool                                          bAllowHighDPIInGameMode;                           // 0x0270(0x0001)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_271[0x3];                                      // 0x0271(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	struct FIntPoint                              DesignScreenSize;                                  // 0x0274(0x0008)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bLoadWidgetsOnDedicatedServer;                     // 0x027C(0x0001)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bAuthorizeAutomaticWidgetVariableCreation;         // 0x027D(0x0001)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_27E[0x2];                                      // 0x027E(0x0002)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<class UObject*>                        CursorClasses;                                     // 0x0280(0x0010)(ZeroConstructor, Transient, UObjectWrapper, NativeAccessSpecifierPrivate)
	TSubclassOf<class UObject>                    CustomScalingRuleClassInstance;                    // 0x0290(0x0008)(ZeroConstructor, Transient, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	class UDPICustomScalingRule*                  CustomScalingRule;                                 // 0x0298(0x0008)(ZeroConstructor, Transient, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_2A0[0x10];                                     // 0x02A0(0x0010)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"UserInterfaceSettings">();
	}
	static class UUserInterfaceSettings* GetDefaultObj()
	{
		return GetDefaultObjImpl<UUserInterfaceSettings>();
	}
};
static_assert(alignof(UUserInterfaceSettings) == 0x000008, "Wrong alignment on UUserInterfaceSettings");
static_assert(sizeof(UUserInterfaceSettings) == 0x0002B0, "Wrong size on UUserInterfaceSettings");
static_assert(offsetof(UUserInterfaceSettings, RenderFocusRule) == 0x000038, "Member 'UUserInterfaceSettings::RenderFocusRule' has a wrong offset!");
static_assert(offsetof(UUserInterfaceSettings, HardwareCursors) == 0x000040, "Member 'UUserInterfaceSettings::HardwareCursors' has a wrong offset!");
static_assert(offsetof(UUserInterfaceSettings, SoftwareCursors) == 0x000090, "Member 'UUserInterfaceSettings::SoftwareCursors' has a wrong offset!");
static_assert(offsetof(UUserInterfaceSettings, DefaultCursor) == 0x0000E0, "Member 'UUserInterfaceSettings::DefaultCursor' has a wrong offset!");
static_assert(offsetof(UUserInterfaceSettings, TextEditBeamCursor) == 0x000100, "Member 'UUserInterfaceSettings::TextEditBeamCursor' has a wrong offset!");
static_assert(offsetof(UUserInterfaceSettings, CrosshairsCursor) == 0x000120, "Member 'UUserInterfaceSettings::CrosshairsCursor' has a wrong offset!");
static_assert(offsetof(UUserInterfaceSettings, HandCursor) == 0x000140, "Member 'UUserInterfaceSettings::HandCursor' has a wrong offset!");
static_assert(offsetof(UUserInterfaceSettings, GrabHandCursor) == 0x000160, "Member 'UUserInterfaceSettings::GrabHandCursor' has a wrong offset!");
static_assert(offsetof(UUserInterfaceSettings, GrabHandClosedCursor) == 0x000180, "Member 'UUserInterfaceSettings::GrabHandClosedCursor' has a wrong offset!");
static_assert(offsetof(UUserInterfaceSettings, SlashedCircleCursor) == 0x0001A0, "Member 'UUserInterfaceSettings::SlashedCircleCursor' has a wrong offset!");
static_assert(offsetof(UUserInterfaceSettings, ApplicationScale) == 0x0001C0, "Member 'UUserInterfaceSettings::ApplicationScale' has a wrong offset!");
static_assert(offsetof(UUserInterfaceSettings, UIScaleRule) == 0x0001C4, "Member 'UUserInterfaceSettings::UIScaleRule' has a wrong offset!");
static_assert(offsetof(UUserInterfaceSettings, CustomScalingRuleClass) == 0x0001C8, "Member 'UUserInterfaceSettings::CustomScalingRuleClass' has a wrong offset!");
static_assert(offsetof(UUserInterfaceSettings, UIScaleCurve) == 0x0001E8, "Member 'UUserInterfaceSettings::UIScaleCurve' has a wrong offset!");
static_assert(offsetof(UUserInterfaceSettings, bAllowHighDPIInGameMode) == 0x000270, "Member 'UUserInterfaceSettings::bAllowHighDPIInGameMode' has a wrong offset!");
static_assert(offsetof(UUserInterfaceSettings, DesignScreenSize) == 0x000274, "Member 'UUserInterfaceSettings::DesignScreenSize' has a wrong offset!");
static_assert(offsetof(UUserInterfaceSettings, bLoadWidgetsOnDedicatedServer) == 0x00027C, "Member 'UUserInterfaceSettings::bLoadWidgetsOnDedicatedServer' has a wrong offset!");
static_assert(offsetof(UUserInterfaceSettings, bAuthorizeAutomaticWidgetVariableCreation) == 0x00027D, "Member 'UUserInterfaceSettings::bAuthorizeAutomaticWidgetVariableCreation' has a wrong offset!");
static_assert(offsetof(UUserInterfaceSettings, CursorClasses) == 0x000280, "Member 'UUserInterfaceSettings::CursorClasses' has a wrong offset!");
static_assert(offsetof(UUserInterfaceSettings, CustomScalingRuleClassInstance) == 0x000290, "Member 'UUserInterfaceSettings::CustomScalingRuleClassInstance' has a wrong offset!");
static_assert(offsetof(UUserInterfaceSettings, CustomScalingRule) == 0x000298, "Member 'UUserInterfaceSettings::CustomScalingRule' has a wrong offset!");

// Class Engine.Canvas
// 0x0368 (0x0390 - 0x0028)
class UCanvas final : public UObject
{
public:
	float                                         OrgX;                                              // 0x0028(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         OrgY;                                              // 0x002C(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         ClipX;                                             // 0x0030(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         ClipY;                                             // 0x0034(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FColor                                 DrawColor;                                         // 0x0038(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bCenterX : 1;                                      // 0x003C(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bCenterY : 1;                                      // 0x003C(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bNoSmooth : 1;                                     // 0x003C(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_3D[0x3];                                       // 0x003D(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	int32                                         SizeX;                                             // 0x0040(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         SizeY;                                             // 0x0044(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_48[0x8];                                       // 0x0048(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	struct FPlane                                 ColorModulate;                                     // 0x0050(0x0020)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UTexture2D*                             DefaultTexture;                                    // 0x0070(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UTexture2D*                             GradientTexture0;                                  // 0x0078(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UReporterGraph*                         ReporterGraph;                                     // 0x0080(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_88[0x308];                                     // 0x0088(0x0308)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void K2_Deproject(const struct FVector2D& ScreenPosition, struct FVector* WorldOrigin, struct FVector* WorldDirection);
	void K2_DrawBorder(class UTexture* BorderTexture, class UTexture* BackgroundTexture, class UTexture* LeftBorderTexture, class UTexture* RightBorderTexture, class UTexture* TopBorderTexture, class UTexture* BottomBorderTexture, const struct FVector2D& ScreenPosition, const struct FVector2D& ScreenSize, const struct FVector2D& CoordinatePosition, const struct FVector2D& CoordinateSize, const struct FLinearColor& RenderColor, const struct FVector2D& BorderScale, const struct FVector2D& BackgroundScale, float Rotation, const struct FVector2D& PivotPoint, const struct FVector2D& CornerSize);
	void K2_DrawBox(const struct FVector2D& ScreenPosition, const struct FVector2D& ScreenSize, float Thickness, const struct FLinearColor& RenderColor);
	void K2_DrawLine(const struct FVector2D& ScreenPositionA, const struct FVector2D& ScreenPositionB, float Thickness, const struct FLinearColor& RenderColor);
	void K2_DrawMaterial(class UMaterialInterface* RenderMaterial, const struct FVector2D& ScreenPosition, const struct FVector2D& ScreenSize, const struct FVector2D& CoordinatePosition, const struct FVector2D& CoordinateSize, float Rotation, const struct FVector2D& PivotPoint);
	void K2_DrawMaterialTriangle(class UMaterialInterface* RenderMaterial, const TArray<struct FCanvasUVTri>& Triangles);
	void K2_DrawPolygon(class UTexture* RenderTexture, const struct FVector2D& ScreenPosition, const struct FVector2D& Radius, int32 NumberOfSides, const struct FLinearColor& RenderColor);
	void K2_DrawText(class UFont* RenderFont, const class FString& RenderText, const struct FVector2D& ScreenPosition, const struct FVector2D& Scale, const struct FLinearColor& RenderColor, float Kerning, const struct FLinearColor& ShadowColor, const struct FVector2D& ShadowOffset, bool bCentreX, bool bCentreY, bool bOutlined, const struct FLinearColor& OutlineColor);
	void K2_DrawTexture(class UTexture* RenderTexture, const struct FVector2D& ScreenPosition, const struct FVector2D& ScreenSize, const struct FVector2D& CoordinatePosition, const struct FVector2D& CoordinateSize, const struct FLinearColor& RenderColor, EBlendMode BlendMode, float Rotation, const struct FVector2D& PivotPoint);
	void K2_DrawTriangle(class UTexture* RenderTexture, const TArray<struct FCanvasUVTri>& Triangles);
	struct FVector K2_Project(const struct FVector& WorldLocation);
	struct FVector2D K2_StrLen(class UFont* RenderFont, const class FString& RenderText);
	struct FVector2D K2_TextSize(class UFont* RenderFont, const class FString& RenderText, const struct FVector2D& Scale);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"Canvas">();
	}
	static class UCanvas* GetDefaultObj()
	{
		return GetDefaultObjImpl<UCanvas>();
	}
};
static_assert(alignof(UCanvas) == 0x000010, "Wrong alignment on UCanvas");
static_assert(sizeof(UCanvas) == 0x000390, "Wrong size on UCanvas");
static_assert(offsetof(UCanvas, OrgX) == 0x000028, "Member 'UCanvas::OrgX' has a wrong offset!");
static_assert(offsetof(UCanvas, OrgY) == 0x00002C, "Member 'UCanvas::OrgY' has a wrong offset!");
static_assert(offsetof(UCanvas, ClipX) == 0x000030, "Member 'UCanvas::ClipX' has a wrong offset!");
static_assert(offsetof(UCanvas, ClipY) == 0x000034, "Member 'UCanvas::ClipY' has a wrong offset!");
static_assert(offsetof(UCanvas, DrawColor) == 0x000038, "Member 'UCanvas::DrawColor' has a wrong offset!");
static_assert(offsetof(UCanvas, SizeX) == 0x000040, "Member 'UCanvas::SizeX' has a wrong offset!");
static_assert(offsetof(UCanvas, SizeY) == 0x000044, "Member 'UCanvas::SizeY' has a wrong offset!");
static_assert(offsetof(UCanvas, ColorModulate) == 0x000050, "Member 'UCanvas::ColorModulate' has a wrong offset!");
static_assert(offsetof(UCanvas, DefaultTexture) == 0x000070, "Member 'UCanvas::DefaultTexture' has a wrong offset!");
static_assert(offsetof(UCanvas, GradientTexture0) == 0x000078, "Member 'UCanvas::GradientTexture0' has a wrong offset!");
static_assert(offsetof(UCanvas, ReporterGraph) == 0x000080, "Member 'UCanvas::ReporterGraph' has a wrong offset!");

// Class Engine.InputSettings
// 0x0118 (0x0140 - 0x0028)
class UInputSettings final : public UObject
{
public:
	TArray<struct FInputAxisConfigEntry>          AxisConfig;                                        // 0x0028(0x0010)(Edit, EditFixedSize, ZeroConstructor, Config, AdvancedDisplay, NativeAccessSpecifierPublic)
	struct FPerPlatformSettings                   PlatformSettings;                                  // 0x0038(0x0010)(Edit, ContainsInstancedReference, NativeAccessSpecifierPublic)
	uint8                                         bAltEnterTogglesFullscreen : 1;                    // 0x0048(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, Config, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bF11TogglesFullscreen : 1;                         // 0x0048(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, Config, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bUseMouseForTouch : 1;                             // 0x0048(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Edit, Config, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bEnableMouseSmoothing : 1;                         // 0x0048(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (Edit, Config, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bEnableFOVScaling : 1;                             // 0x0048(0x0001)(BitIndex: 0x04, PropSize: 0x0001 (Edit, Config, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bCaptureMouseOnLaunch : 1;                         // 0x0048(0x0001)(BitIndex: 0x05, PropSize: 0x0001 (Edit, Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bEnableLegacyInputScales : 1;                      // 0x0048(0x0001)(BitIndex: 0x06, PropSize: 0x0001 (Edit, Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bEnableMotionControls : 1;                         // 0x0048(0x0001)(BitIndex: 0x07, PropSize: 0x0001 (Edit, Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bFilterInputByPlatformUser : 1;                    // 0x0049(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bEnableInputDeviceSubsystem : 1;                   // 0x0049(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bShouldFlushPressedKeysOnViewportFocusLost : 1;    // 0x0049(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Edit, Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bEnableDynamicComponentInputBinding : 1;           // 0x0049(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (Edit, Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bAlwaysShowTouchInterface : 1;                     // 0x0049(0x0001)(BitIndex: 0x04, PropSize: 0x0001 (Edit, Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bShowConsoleOnFourFingerTap : 1;                   // 0x0049(0x0001)(BitIndex: 0x05, PropSize: 0x0001 (Edit, Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bEnableGestureRecognizer : 1;                      // 0x0049(0x0001)(BitIndex: 0x06, PropSize: 0x0001 (Edit, Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bUseAutocorrect : 1;                               // 0x0049(0x0001)(BitIndex: 0x07, PropSize: 0x0001 (Edit, Config, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_4A[0x6];                                       // 0x004A(0x0006)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<class FString>                         ExcludedAutocorrectOS;                             // 0x0050(0x0010)(Edit, ZeroConstructor, Config, AdvancedDisplay, NativeAccessSpecifierPublic)
	TArray<class FString>                         ExcludedAutocorrectCultures;                       // 0x0060(0x0010)(Edit, ZeroConstructor, Config, AdvancedDisplay, NativeAccessSpecifierPublic)
	TArray<class FString>                         ExcludedAutocorrectDeviceModels;                   // 0x0070(0x0010)(Edit, ZeroConstructor, Config, AdvancedDisplay, NativeAccessSpecifierPublic)
	EMouseCaptureMode                             DefaultViewportMouseCaptureMode;                   // 0x0080(0x0001)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EMouseLockMode                                DefaultViewportMouseLockMode;                      // 0x0081(0x0001)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_82[0x2];                                       // 0x0082(0x0002)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         FOVScale;                                          // 0x0084(0x0004)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         DoubleClickTime;                                   // 0x0088(0x0004)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_8C[0x4];                                       // 0x008C(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<struct FInputActionKeyMapping>         ActionMappings;                                    // 0x0090(0x0010)(Edit, ZeroConstructor, Config, NativeAccessSpecifierPrivate)
	TArray<struct FInputAxisKeyMapping>           AxisMappings;                                      // 0x00A0(0x0010)(Edit, ZeroConstructor, Config, NativeAccessSpecifierPrivate)
	TArray<struct FInputActionSpeechMapping>      SpeechMappings;                                    // 0x00B0(0x0010)(Edit, ZeroConstructor, Config, NativeAccessSpecifierPrivate)
	TSoftClassPtr<class UClass>                   DefaultPlayerInputClass;                           // 0x00C0(0x0028)(Edit, Config, NoClear, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	TSoftClassPtr<class UClass>                   DefaultInputComponentClass;                        // 0x00E8(0x0028)(Edit, Config, NoClear, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	struct FSoftObjectPath                        DefaultTouchInterface;                             // 0x0110(0x0020)(Edit, ZeroConstructor, Config, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TArray<struct FKey>                           ConsoleKeys;                                       // 0x0130(0x0010)(Edit, ZeroConstructor, Config, NativeAccessSpecifierPublic)

public:
	static class UInputSettings* GetInputSettings();

	void AddActionMapping(const struct FInputActionKeyMapping& KeyMapping, bool bForceRebuildKeymaps);
	void AddAxisMapping(const struct FInputAxisKeyMapping& KeyMapping, bool bForceRebuildKeymaps);
	void ForceRebuildKeymaps();
	void RemoveActionMapping(const struct FInputActionKeyMapping& KeyMapping, bool bForceRebuildKeymaps);
	void RemoveAxisMapping(const struct FInputAxisKeyMapping& KeyMapping, bool bForceRebuildKeymaps);
	void SaveKeyMappings();

	void GetActionMappingByName(const class FName InActionName, TArray<struct FInputActionKeyMapping>* OutMappings) const;
	void GetActionNames(TArray<class FName>* ActionNames) const;
	void GetAxisMappingByName(const class FName InAxisName, TArray<struct FInputAxisKeyMapping>* OutMappings) const;
	void GetAxisNames(TArray<class FName>* AxisNames) const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"InputSettings">();
	}
	static class UInputSettings* GetDefaultObj()
	{
		return GetDefaultObjImpl<UInputSettings>();
	}
};
static_assert(alignof(UInputSettings) == 0x000008, "Wrong alignment on UInputSettings");
static_assert(sizeof(UInputSettings) == 0x000140, "Wrong size on UInputSettings");
static_assert(offsetof(UInputSettings, AxisConfig) == 0x000028, "Member 'UInputSettings::AxisConfig' has a wrong offset!");
static_assert(offsetof(UInputSettings, PlatformSettings) == 0x000038, "Member 'UInputSettings::PlatformSettings' has a wrong offset!");
static_assert(offsetof(UInputSettings, ExcludedAutocorrectOS) == 0x000050, "Member 'UInputSettings::ExcludedAutocorrectOS' has a wrong offset!");
static_assert(offsetof(UInputSettings, ExcludedAutocorrectCultures) == 0x000060, "Member 'UInputSettings::ExcludedAutocorrectCultures' has a wrong offset!");
static_assert(offsetof(UInputSettings, ExcludedAutocorrectDeviceModels) == 0x000070, "Member 'UInputSettings::ExcludedAutocorrectDeviceModels' has a wrong offset!");
static_assert(offsetof(UInputSettings, DefaultViewportMouseCaptureMode) == 0x000080, "Member 'UInputSettings::DefaultViewportMouseCaptureMode' has a wrong offset!");
static_assert(offsetof(UInputSettings, DefaultViewportMouseLockMode) == 0x000081, "Member 'UInputSettings::DefaultViewportMouseLockMode' has a wrong offset!");
static_assert(offsetof(UInputSettings, FOVScale) == 0x000084, "Member 'UInputSettings::FOVScale' has a wrong offset!");
static_assert(offsetof(UInputSettings, DoubleClickTime) == 0x000088, "Member 'UInputSettings::DoubleClickTime' has a wrong offset!");
static_assert(offsetof(UInputSettings, ActionMappings) == 0x000090, "Member 'UInputSettings::ActionMappings' has a wrong offset!");
static_assert(offsetof(UInputSettings, AxisMappings) == 0x0000A0, "Member 'UInputSettings::AxisMappings' has a wrong offset!");
static_assert(offsetof(UInputSettings, SpeechMappings) == 0x0000B0, "Member 'UInputSettings::SpeechMappings' has a wrong offset!");
static_assert(offsetof(UInputSettings, DefaultPlayerInputClass) == 0x0000C0, "Member 'UInputSettings::DefaultPlayerInputClass' has a wrong offset!");
static_assert(offsetof(UInputSettings, DefaultInputComponentClass) == 0x0000E8, "Member 'UInputSettings::DefaultInputComponentClass' has a wrong offset!");
static_assert(offsetof(UInputSettings, DefaultTouchInterface) == 0x000110, "Member 'UInputSettings::DefaultTouchInterface' has a wrong offset!");
static_assert(offsetof(UInputSettings, ConsoleKeys) == 0x000130, "Member 'UInputSettings::ConsoleKeys' has a wrong offset!");

// Class Engine.InputPlatformSettings
// 0x0028 (0x0068 - 0x0040)
class UInputPlatformSettings final : public UPlatformSettings
{
public:
	int32                                         MaxTriggerFeedbackPosition;                        // 0x0040(0x0004)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         MaxTriggerFeedbackStrength;                        // 0x0044(0x0004)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         MaxTriggerVibrationTriggerPosition;                // 0x0048(0x0004)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         MaxTriggerVibrationFrequency;                      // 0x004C(0x0004)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         MaxTriggerVibrationAmplitude;                      // 0x0050(0x0004)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_54[0x4];                                       // 0x0054(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<struct FHardwareDeviceIdentifier>      HardwareDevices;                                   // 0x0058(0x0010)(Edit, ZeroConstructor, Config, Protected, NativeAccessSpecifierProtected)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"InputPlatformSettings">();
	}
	static class UInputPlatformSettings* GetDefaultObj()
	{
		return GetDefaultObjImpl<UInputPlatformSettings>();
	}
};
static_assert(alignof(UInputPlatformSettings) == 0x000008, "Wrong alignment on UInputPlatformSettings");
static_assert(sizeof(UInputPlatformSettings) == 0x000068, "Wrong size on UInputPlatformSettings");
static_assert(offsetof(UInputPlatformSettings, MaxTriggerFeedbackPosition) == 0x000040, "Member 'UInputPlatformSettings::MaxTriggerFeedbackPosition' has a wrong offset!");
static_assert(offsetof(UInputPlatformSettings, MaxTriggerFeedbackStrength) == 0x000044, "Member 'UInputPlatformSettings::MaxTriggerFeedbackStrength' has a wrong offset!");
static_assert(offsetof(UInputPlatformSettings, MaxTriggerVibrationTriggerPosition) == 0x000048, "Member 'UInputPlatformSettings::MaxTriggerVibrationTriggerPosition' has a wrong offset!");
static_assert(offsetof(UInputPlatformSettings, MaxTriggerVibrationFrequency) == 0x00004C, "Member 'UInputPlatformSettings::MaxTriggerVibrationFrequency' has a wrong offset!");
static_assert(offsetof(UInputPlatformSettings, MaxTriggerVibrationAmplitude) == 0x000050, "Member 'UInputPlatformSettings::MaxTriggerVibrationAmplitude' has a wrong offset!");
static_assert(offsetof(UInputPlatformSettings, HardwareDevices) == 0x000058, "Member 'UInputPlatformSettings::HardwareDevices' has a wrong offset!");

// Class Engine.PlayerInput
// 0x0470 (0x0498 - 0x0028)
class UPlayerInput : public UObject
{
public:
	uint8                                         Pad_28[0x178];                                     // 0x0028(0x0178)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<struct FKeyBind>                       DebugExecBindings;                                 // 0x01A0(0x0010)(ZeroConstructor, Config, NativeAccessSpecifierPublic)
	uint8                                         Pad_1B0[0x30];                                     // 0x01B0(0x0030)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<class FName>                           InvertedAxis;                                      // 0x01E0(0x0010)(ZeroConstructor, Config, NativeAccessSpecifierPublic)
	uint8                                         Pad_1F0[0x2A8];                                    // 0x01F0(0x02A8)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void ClearSmoothing();
	void InvertAxis(const class FName AxisName);
	void InvertAxisKey(const struct FKey& AxisKey);
	void SetBind(class FName BindName, const class FString& Command);
	void SetMouseSensitivity(const float Sensitivity);

	class APlayerController* GetOuterAPlayerController() const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"PlayerInput">();
	}
	static class UPlayerInput* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPlayerInput>();
	}
};
static_assert(alignof(UPlayerInput) == 0x000008, "Wrong alignment on UPlayerInput");
static_assert(sizeof(UPlayerInput) == 0x000498, "Wrong size on UPlayerInput");
static_assert(offsetof(UPlayerInput, DebugExecBindings) == 0x0001A0, "Member 'UPlayerInput::DebugExecBindings' has a wrong offset!");
static_assert(offsetof(UPlayerInput, InvertedAxis) == 0x0001E0, "Member 'UPlayerInput::InvertedAxis' has a wrong offset!");

// Class Engine.TireType
// 0x0008 (0x0038 - 0x0030)
class UTireType final : public UDataAsset
{
public:
	float                                         FrictionScale;                                     // 0x0030(0x0004)(Edit, ZeroConstructor, EditConst, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_34[0x4];                                       // 0x0034(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"TireType">();
	}
	static class UTireType* GetDefaultObj()
	{
		return GetDefaultObjImpl<UTireType>();
	}
};
static_assert(alignof(UTireType) == 0x000008, "Wrong alignment on UTireType");
static_assert(sizeof(UTireType) == 0x000038, "Wrong size on UTireType");
static_assert(offsetof(UTireType, FrictionScale) == 0x000030, "Member 'UTireType::FrictionScale' has a wrong offset!");

// Class Engine.VisualLoggerAutomationTests
// 0x0000 (0x0028 - 0x0028)
class UVisualLoggerAutomationTests final : public UObject
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"VisualLoggerAutomationTests">();
	}
	static class UVisualLoggerAutomationTests* GetDefaultObj()
	{
		return GetDefaultObjImpl<UVisualLoggerAutomationTests>();
	}
};
static_assert(alignof(UVisualLoggerAutomationTests) == 0x000008, "Wrong alignment on UVisualLoggerAutomationTests");
static_assert(sizeof(UVisualLoggerAutomationTests) == 0x000028, "Wrong size on UVisualLoggerAutomationTests");

// Class Engine.VisualLoggerFilterVolume
// 0x0000 (0x02D8 - 0x02D8)
class AVisualLoggerFilterVolume final : public AVolume
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"VisualLoggerFilterVolume">();
	}
	static class AVisualLoggerFilterVolume* GetDefaultObj()
	{
		return GetDefaultObjImpl<AVisualLoggerFilterVolume>();
	}
};
static_assert(alignof(AVisualLoggerFilterVolume) == 0x000008, "Wrong alignment on AVisualLoggerFilterVolume");
static_assert(sizeof(AVisualLoggerFilterVolume) == 0x0002D8, "Wrong size on AVisualLoggerFilterVolume");

// Class Engine.VoiceChannel
// 0x0010 (0x0078 - 0x0068)
class UVoiceChannel final : public UChannel
{
public:
	uint8                                         Pad_68[0x10];                                      // 0x0068(0x0010)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"VoiceChannel">();
	}
	static class UVoiceChannel* GetDefaultObj()
	{
		return GetDefaultObjImpl<UVoiceChannel>();
	}
};
static_assert(alignof(UVoiceChannel) == 0x000008, "Wrong alignment on UVoiceChannel");
static_assert(sizeof(UVoiceChannel) == 0x000078, "Wrong size on UVoiceChannel");

// Class Engine.VOIPTalker
// 0x0040 (0x00E8 - 0x00A8)
class UVOIPTalker final : public UActorComponent
{
public:
	struct FVoiceSettings                         Settings;                                          // 0x00A8(0x0018)(Edit, BlueprintVisible, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
	uint8                                         Pad_C0[0x28];                                      // 0x00C0(0x0028)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UVOIPTalker* CreateTalkerForPlayer(class APlayerState* OwningState);

	void BPOnTalkingBegin(class UAudioComponent* AudioComponent);
	void BPOnTalkingEnd();
	float GetVoiceLevel();
	void RegisterWithPlayerState(class APlayerState* OwningState);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"VOIPTalker">();
	}
	static class UVOIPTalker* GetDefaultObj()
	{
		return GetDefaultObjImpl<UVOIPTalker>();
	}
};
static_assert(alignof(UVOIPTalker) == 0x000008, "Wrong alignment on UVOIPTalker");
static_assert(sizeof(UVOIPTalker) == 0x0000E8, "Wrong size on UVOIPTalker");
static_assert(offsetof(UVOIPTalker, Settings) == 0x0000A8, "Member 'UVOIPTalker::Settings' has a wrong offset!");

// Class Engine.VOIPStatics
// 0x0000 (0x0028 - 0x0028)
class UVOIPStatics final : public UBlueprintFunctionLibrary
{
public:
	static void SetMicThreshold(float InThreshold);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"VOIPStatics">();
	}
	static class UVOIPStatics* GetDefaultObj()
	{
		return GetDefaultObjImpl<UVOIPStatics>();
	}
};
static_assert(alignof(UVOIPStatics) == 0x000008, "Wrong alignment on UVOIPStatics");
static_assert(sizeof(UVOIPStatics) == 0x000028, "Wrong size on UVOIPStatics");

// Class Engine.VolumetricLightmapDensityVolume
// 0x0008 (0x02E0 - 0x02D8)
class AVolumetricLightmapDensityVolume final : public AVolume
{
public:
	struct FInt32Interval                         AllowedMipLevelRange;                              // 0x02D8(0x0008)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"VolumetricLightmapDensityVolume">();
	}
	static class AVolumetricLightmapDensityVolume* GetDefaultObj()
	{
		return GetDefaultObjImpl<AVolumetricLightmapDensityVolume>();
	}
};
static_assert(alignof(AVolumetricLightmapDensityVolume) == 0x000008, "Wrong alignment on AVolumetricLightmapDensityVolume");
static_assert(sizeof(AVolumetricLightmapDensityVolume) == 0x0002E0, "Wrong size on AVolumetricLightmapDensityVolume");
static_assert(offsetof(AVolumetricLightmapDensityVolume, AllowedMipLevelRange) == 0x0002D8, "Member 'AVolumetricLightmapDensityVolume::AllowedMipLevelRange' has a wrong offset!");

// Class Engine.LightMapVirtualTexture2D
// 0x0010 (0x0290 - 0x0280)
class ULightMapVirtualTexture2D final : public UTexture2D
{
public:
	TArray<int8>                                  TypeToLayer;                                       // 0x0278(0x0010)(Edit, ZeroConstructor, NativeAccessSpecifierPublic)
	uint8                                         Pad_288[0x8];                                      // 0x0288(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"LightMapVirtualTexture2D">();
	}
	static class ULightMapVirtualTexture2D* GetDefaultObj()
	{
		return GetDefaultObjImpl<ULightMapVirtualTexture2D>();
	}
};
static_assert(alignof(ULightMapVirtualTexture2D) == 0x000010, "Wrong alignment on ULightMapVirtualTexture2D");
static_assert(sizeof(ULightMapVirtualTexture2D) == 0x000290, "Wrong size on ULightMapVirtualTexture2D");
static_assert(offsetof(ULightMapVirtualTexture2D, TypeToLayer) == 0x000278, "Member 'ULightMapVirtualTexture2D::TypeToLayer' has a wrong offset!");

// Class Engine.VirtualTexture
// 0x0000 (0x0028 - 0x0028)
class UVirtualTexture : public UObject
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"VirtualTexture">();
	}
	static class UVirtualTexture* GetDefaultObj()
	{
		return GetDefaultObjImpl<UVirtualTexture>();
	}
};
static_assert(alignof(UVirtualTexture) == 0x000008, "Wrong alignment on UVirtualTexture");
static_assert(sizeof(UVirtualTexture) == 0x000028, "Wrong size on UVirtualTexture");

// Class Engine.LightMapVirtualTexture
// 0x0000 (0x0028 - 0x0028)
class ULightMapVirtualTexture final : public UVirtualTexture
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"LightMapVirtualTexture">();
	}
	static class ULightMapVirtualTexture* GetDefaultObj()
	{
		return GetDefaultObjImpl<ULightMapVirtualTexture>();
	}
};
static_assert(alignof(ULightMapVirtualTexture) == 0x000008, "Wrong alignment on ULightMapVirtualTexture");
static_assert(sizeof(ULightMapVirtualTexture) == 0x000028, "Wrong size on ULightMapVirtualTexture");

// Class Engine.RuntimeVirtualTextureStreamingProxy
// 0x0000 (0x0280 - 0x0280)
class URuntimeVirtualTextureStreamingProxy final : public UTexture2D
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"RuntimeVirtualTextureStreamingProxy">();
	}
	static class URuntimeVirtualTextureStreamingProxy* GetDefaultObj()
	{
		return GetDefaultObjImpl<URuntimeVirtualTextureStreamingProxy>();
	}
};
static_assert(alignof(URuntimeVirtualTextureStreamingProxy) == 0x000010, "Wrong alignment on URuntimeVirtualTextureStreamingProxy");
static_assert(sizeof(URuntimeVirtualTextureStreamingProxy) == 0x000280, "Wrong size on URuntimeVirtualTextureStreamingProxy");

// Class Engine.VirtualTextureBuilder
// 0x0020 (0x0048 - 0x0028)
class UVirtualTextureBuilder final : public UObject
{
public:
	class UVirtualTexture2D*                      Texture;                                           // 0x0028(0x0008)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, EditConst, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UVirtualTexture2D*                      TextureMobile;                                     // 0x0030(0x0008)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, EditConst, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint64                                        BuildHash;                                         // 0x0038(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bSeparateTextureForMobile;                         // 0x0040(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_41[0x7];                                       // 0x0041(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"VirtualTextureBuilder">();
	}
	static class UVirtualTextureBuilder* GetDefaultObj()
	{
		return GetDefaultObjImpl<UVirtualTextureBuilder>();
	}
};
static_assert(alignof(UVirtualTextureBuilder) == 0x000008, "Wrong alignment on UVirtualTextureBuilder");
static_assert(sizeof(UVirtualTextureBuilder) == 0x000048, "Wrong size on UVirtualTextureBuilder");
static_assert(offsetof(UVirtualTextureBuilder, Texture) == 0x000028, "Member 'UVirtualTextureBuilder::Texture' has a wrong offset!");
static_assert(offsetof(UVirtualTextureBuilder, TextureMobile) == 0x000030, "Member 'UVirtualTextureBuilder::TextureMobile' has a wrong offset!");
static_assert(offsetof(UVirtualTextureBuilder, BuildHash) == 0x000038, "Member 'UVirtualTextureBuilder::BuildHash' has a wrong offset!");
static_assert(offsetof(UVirtualTextureBuilder, bSeparateTextureForMobile) == 0x000040, "Member 'UVirtualTextureBuilder::bSeparateTextureForMobile' has a wrong offset!");

// Class Engine.VirtualTexturePoolConfig
// 0x0018 (0x0040 - 0x0028)
class UVirtualTexturePoolConfig final : public UObject
{
public:
	int32                                         DefaultSizeInMegabyte;                             // 0x0028(0x0004)(ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_2C[0x4];                                       // 0x002C(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<struct FVirtualTextureSpacePoolConfig> Pools;                                             // 0x0030(0x0010)(ZeroConstructor, Config, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"VirtualTexturePoolConfig">();
	}
	static class UVirtualTexturePoolConfig* GetDefaultObj()
	{
		return GetDefaultObjImpl<UVirtualTexturePoolConfig>();
	}
};
static_assert(alignof(UVirtualTexturePoolConfig) == 0x000008, "Wrong alignment on UVirtualTexturePoolConfig");
static_assert(sizeof(UVirtualTexturePoolConfig) == 0x000040, "Wrong size on UVirtualTexturePoolConfig");
static_assert(offsetof(UVirtualTexturePoolConfig, DefaultSizeInMegabyte) == 0x000028, "Member 'UVirtualTexturePoolConfig::DefaultSizeInMegabyte' has a wrong offset!");
static_assert(offsetof(UVirtualTexturePoolConfig, Pools) == 0x000030, "Member 'UVirtualTexturePoolConfig::Pools' has a wrong offset!");

// Class Engine.WindDirectionalSource
// 0x0008 (0x02A8 - 0x02A0)
class AWindDirectionalSource final : public AInfo
{
public:
	class UWindDirectionalSourceComponent*        Component;                                         // 0x02A0(0x0008)(Edit, BlueprintVisible, ExportObject, BlueprintReadOnly, ZeroConstructor, EditConst, InstancedReference, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"WindDirectionalSource">();
	}
	static class AWindDirectionalSource* GetDefaultObj()
	{
		return GetDefaultObjImpl<AWindDirectionalSource>();
	}
};
static_assert(alignof(AWindDirectionalSource) == 0x000008, "Wrong alignment on AWindDirectionalSource");
static_assert(sizeof(AWindDirectionalSource) == 0x0002A8, "Wrong size on AWindDirectionalSource");
static_assert(offsetof(AWindDirectionalSource, Component) == 0x0002A0, "Member 'AWindDirectionalSource::Component' has a wrong offset!");

// Class Engine.WorldPartitionBlueprintLibrary
// 0x0000 (0x0028 - 0x0028)
class UWorldPartitionBlueprintLibrary final : public UBlueprintFunctionLibrary
{
public:
	static bool GetActorDescs(TArray<struct FActorDesc>* OutActorDescs);
	static class UDataLayerManager* GetDataLayerManager(class UObject* WorldContextObject);
	static struct FBox GetEditorWorldBounds();
	static bool GetIntersectingActorDescs(const struct FBox& InBox, TArray<struct FActorDesc>* OutActorDescs);
	static struct FBox GetRuntimeWorldBounds();
	static void LoadActors(const TArray<struct FGuid>& InActorsToLoad);
	static void PinActors(const TArray<struct FGuid>& InActorsToPin);
	static void UnloadActors(const TArray<struct FGuid>& InActorsToUnload);
	static void UnpinActors(const TArray<struct FGuid>& InActorsToUnpin);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"WorldPartitionBlueprintLibrary">();
	}
	static class UWorldPartitionBlueprintLibrary* GetDefaultObj()
	{
		return GetDefaultObjImpl<UWorldPartitionBlueprintLibrary>();
	}
};
static_assert(alignof(UWorldPartitionBlueprintLibrary) == 0x000008, "Wrong alignment on UWorldPartitionBlueprintLibrary");
static_assert(sizeof(UWorldPartitionBlueprintLibrary) == 0x000028, "Wrong size on UWorldPartitionBlueprintLibrary");

// Class Engine.ActorDescContainer
// 0x0000 (0x0028 - 0x0028)
class UActorDescContainer final : public UObject
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ActorDescContainer">();
	}
	static class UActorDescContainer* GetDefaultObj()
	{
		return GetDefaultObjImpl<UActorDescContainer>();
	}
};
static_assert(alignof(UActorDescContainer) == 0x000008, "Wrong alignment on UActorDescContainer");
static_assert(sizeof(UActorDescContainer) == 0x000028, "Wrong size on UActorDescContainer");

// Class Engine.ContentBundleDescriptor
// 0x0028 (0x0050 - 0x0028)
class UContentBundleDescriptor final : public UObject
{
public:
	class FString                                 DisplayName;                                       // 0x0028(0x0010)(Edit, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	struct FColor                                 DebugColor;                                        // 0x0038(0x0004)(Edit, ZeroConstructor, DuplicateTransient, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	struct FGuid                                  Guid;                                              // 0x003C(0x0010)(Edit, ZeroConstructor, EditConst, DuplicateTransient, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_4C[0x4];                                       // 0x004C(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ContentBundleDescriptor">();
	}
	static class UContentBundleDescriptor* GetDefaultObj()
	{
		return GetDefaultObjImpl<UContentBundleDescriptor>();
	}
};
static_assert(alignof(UContentBundleDescriptor) == 0x000008, "Wrong alignment on UContentBundleDescriptor");
static_assert(sizeof(UContentBundleDescriptor) == 0x000050, "Wrong size on UContentBundleDescriptor");
static_assert(offsetof(UContentBundleDescriptor, DisplayName) == 0x000028, "Member 'UContentBundleDescriptor::DisplayName' has a wrong offset!");
static_assert(offsetof(UContentBundleDescriptor, DebugColor) == 0x000038, "Member 'UContentBundleDescriptor::DebugColor' has a wrong offset!");
static_assert(offsetof(UContentBundleDescriptor, Guid) == 0x00003C, "Member 'UContentBundleDescriptor::Guid' has a wrong offset!");

// Class Engine.ContentBundleEngineSubsystem
// 0x00A0 (0x00D0 - 0x0030)
class UContentBundleEngineSubsystem final : public UEngineSubsystem
{
public:
	uint8                                         Pad_30[0x70];                                      // 0x0030(0x0070)(Fixing Size After Last Property [ Dumper-7 ])
	TSoftClassPtr<class UClass>                   ContentBundleTypeFactoryClass;                     // 0x00A0(0x0028)(Config, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	class UContentBundleTypeFactory*              ContentBundleTypeFactory;                          // 0x00C8(0x0008)(ZeroConstructor, Transient, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ContentBundleEngineSubsystem">();
	}
	static class UContentBundleEngineSubsystem* GetDefaultObj()
	{
		return GetDefaultObjImpl<UContentBundleEngineSubsystem>();
	}
};
static_assert(alignof(UContentBundleEngineSubsystem) == 0x000008, "Wrong alignment on UContentBundleEngineSubsystem");
static_assert(sizeof(UContentBundleEngineSubsystem) == 0x0000D0, "Wrong size on UContentBundleEngineSubsystem");
static_assert(offsetof(UContentBundleEngineSubsystem, ContentBundleTypeFactoryClass) == 0x0000A0, "Member 'UContentBundleEngineSubsystem::ContentBundleTypeFactoryClass' has a wrong offset!");
static_assert(offsetof(UContentBundleEngineSubsystem, ContentBundleTypeFactory) == 0x0000C8, "Member 'UContentBundleEngineSubsystem::ContentBundleTypeFactory' has a wrong offset!");

// Class Engine.ContentBundleManager
// 0x0010 (0x0038 - 0x0028)
class UContentBundleManager final : public UObject
{
public:
	uint8                                         Pad_28[0x10];                                      // 0x0028(0x0010)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ContentBundleManager">();
	}
	static class UContentBundleManager* GetDefaultObj()
	{
		return GetDefaultObjImpl<UContentBundleManager>();
	}
};
static_assert(alignof(UContentBundleManager) == 0x000008, "Wrong alignment on UContentBundleManager");
static_assert(sizeof(UContentBundleManager) == 0x000038, "Wrong size on UContentBundleManager");

// Class Engine.ContentBundleDuplicateForPIEHelper
// 0x0000 (0x0028 - 0x0028)
class UContentBundleDuplicateForPIEHelper final : public UObject
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ContentBundleDuplicateForPIEHelper">();
	}
	static class UContentBundleDuplicateForPIEHelper* GetDefaultObj()
	{
		return GetDefaultObjImpl<UContentBundleDuplicateForPIEHelper>();
	}
};
static_assert(alignof(UContentBundleDuplicateForPIEHelper) == 0x000008, "Wrong alignment on UContentBundleDuplicateForPIEHelper");
static_assert(sizeof(UContentBundleDuplicateForPIEHelper) == 0x000028, "Wrong size on UContentBundleDuplicateForPIEHelper");

// Class Engine.DataLayer
// 0x0030 (0x0058 - 0x0028)
class UDataLayer final : public UObject
{
public:
	class FName                                   DataLayerLabel;                                    // 0x0028(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         bIsRuntime : 1;                                    // 0x0030(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate))
	uint8                                         Pad_31[0x3];                                       // 0x0031(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	EDataLayerRuntimeState                        InitialRuntimeState;                               // 0x0034(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_35[0x3];                                       // 0x0035(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	struct FColor                                 DebugColor;                                        // 0x0038(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_3C[0x4];                                       // 0x003C(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	class UDataLayer*                             Parent;                                            // 0x0040(0x0008)(ZeroConstructor, Deprecated, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	TArray<class UDataLayer*>                     Children;                                          // 0x0048(0x0010)(ZeroConstructor, Transient, Deprecated, UObjectWrapper, NativeAccessSpecifierPrivate)

public:
	bool Equals(const struct FActorDataLayer& ActorDataLayer) const;
	class FName GetDataLayerLabel() const;
	struct FColor GetDebugColor() const;
	EDataLayerRuntimeState GetInitialRuntimeState() const;
	EDataLayerState GetInitialState() const;
	bool IsDynamicallyLoaded() const;
	bool IsEffectiveVisible() const;
	bool IsInitiallyActive() const;
	bool IsInitiallyVisible() const;
	bool IsRuntime() const;
	bool IsVisible() const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"DataLayer">();
	}
	static class UDataLayer* GetDefaultObj()
	{
		return GetDefaultObjImpl<UDataLayer>();
	}
};
static_assert(alignof(UDataLayer) == 0x000008, "Wrong alignment on UDataLayer");
static_assert(sizeof(UDataLayer) == 0x000058, "Wrong size on UDataLayer");
static_assert(offsetof(UDataLayer, DataLayerLabel) == 0x000028, "Member 'UDataLayer::DataLayerLabel' has a wrong offset!");
static_assert(offsetof(UDataLayer, InitialRuntimeState) == 0x000034, "Member 'UDataLayer::InitialRuntimeState' has a wrong offset!");
static_assert(offsetof(UDataLayer, DebugColor) == 0x000038, "Member 'UDataLayer::DebugColor' has a wrong offset!");
static_assert(offsetof(UDataLayer, Parent) == 0x000040, "Member 'UDataLayer::Parent' has a wrong offset!");
static_assert(offsetof(UDataLayer, Children) == 0x000048, "Member 'UDataLayer::Children' has a wrong offset!");

// Class Engine.DataLayerAsset
// 0x0008 (0x0030 - 0x0028)
class UDataLayerAsset final : public UObject
{
public:
	EDataLayerType                                DataLayerType;                                     // 0x0028(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	bool                                          bSupportsActorFilters;                             // 0x0029(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_2A[0x2];                                       // 0x002A(0x0002)(Fixing Size After Last Property [ Dumper-7 ])
	struct FColor                                 DebugColor;                                        // 0x002C(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)

public:
	struct FColor GetDebugColor() const;
	EDataLayerType GetType() const;
	bool IsRuntime() const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"DataLayerAsset">();
	}
	static class UDataLayerAsset* GetDefaultObj()
	{
		return GetDefaultObjImpl<UDataLayerAsset>();
	}
};
static_assert(alignof(UDataLayerAsset) == 0x000008, "Wrong alignment on UDataLayerAsset");
static_assert(sizeof(UDataLayerAsset) == 0x000030, "Wrong size on UDataLayerAsset");
static_assert(offsetof(UDataLayerAsset, DataLayerType) == 0x000028, "Member 'UDataLayerAsset::DataLayerType' has a wrong offset!");
static_assert(offsetof(UDataLayerAsset, bSupportsActorFilters) == 0x000029, "Member 'UDataLayerAsset::bSupportsActorFilters' has a wrong offset!");
static_assert(offsetof(UDataLayerAsset, DebugColor) == 0x00002C, "Member 'UDataLayerAsset::DebugColor' has a wrong offset!");

// Class Engine.DataLayerInstanceWithAsset
// 0x0008 (0x0050 - 0x0048)
class UDataLayerInstanceWithAsset final : public UDataLayerInstance
{
public:
	class UDataLayerAsset*                        DataLayerAsset;                                    // 0x0048(0x0008)(Edit, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"DataLayerInstanceWithAsset">();
	}
	static class UDataLayerInstanceWithAsset* GetDefaultObj()
	{
		return GetDefaultObjImpl<UDataLayerInstanceWithAsset>();
	}
};
static_assert(alignof(UDataLayerInstanceWithAsset) == 0x000008, "Wrong alignment on UDataLayerInstanceWithAsset");
static_assert(sizeof(UDataLayerInstanceWithAsset) == 0x000050, "Wrong size on UDataLayerInstanceWithAsset");
static_assert(offsetof(UDataLayerInstanceWithAsset, DataLayerAsset) == 0x000048, "Member 'UDataLayerInstanceWithAsset::DataLayerAsset' has a wrong offset!");

// Class Engine.DataLayerLoadingPolicy
// 0x0000 (0x0028 - 0x0028)
class UDataLayerLoadingPolicy final : public UObject
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"DataLayerLoadingPolicy">();
	}
	static class UDataLayerLoadingPolicy* GetDefaultObj()
	{
		return GetDefaultObjImpl<UDataLayerLoadingPolicy>();
	}
};
static_assert(alignof(UDataLayerLoadingPolicy) == 0x000008, "Wrong alignment on UDataLayerLoadingPolicy");
static_assert(sizeof(UDataLayerLoadingPolicy) == 0x000028, "Wrong size on UDataLayerLoadingPolicy");

// Class Engine.DataLayerSubsystem
// 0x0038 (0x0068 - 0x0030)
class UDataLayerSubsystem final : public UWorldSubsystem
{
public:
	TMulticastInlineDelegate<void(const class UDataLayerInstance* DataLayer, EDataLayerRuntimeState State)> OnDataLayerRuntimeStateChanged; // 0x0030(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	TSoftClassPtr<class UClass>                   DataLayerLoadingPolicyClass;                       // 0x0040(0x0028)(Config, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)

public:
	void SetDataLayerInstanceRuntimeState(const class UDataLayerAsset* InDataLayerAsset, EDataLayerRuntimeState InState, bool bInIsRecursive);
	void SetDataLayerRuntimeState(const struct FActorDataLayer& InDataLayer, EDataLayerRuntimeState InState, bool bInIsRecursive);
	void SetDataLayerRuntimeStateByLabel(const class FName& InDataLayerLabel, EDataLayerRuntimeState InState, bool bInIsRecursive);
	void SetDataLayerState(const struct FActorDataLayer& InDataLayer, EDataLayerState InState);
	void SetDataLayerStateByLabel(const class FName& InDataLayerLabel, EDataLayerState InState);

	const TSet<class FName> GetActiveDataLayerNames() const;
	class UDataLayerInstance* GetDataLayer(const struct FActorDataLayer& InDataLayer) const;
	EDataLayerRuntimeState GetDataLayerEffectiveRuntimeState(const struct FActorDataLayer& InDataLayer) const;
	EDataLayerRuntimeState GetDataLayerEffectiveRuntimeStateByLabel(const class FName& InDataLayerLabel) const;
	class UDataLayerInstance* GetDataLayerFromLabel(class FName InDataLayerLabel) const;
	class UDataLayerInstance* GetDataLayerFromName(class FName InDataLayerName) const;
	EDataLayerRuntimeState GetDataLayerInstanceEffectiveRuntimeState(const class UDataLayerAsset* InDataLayerAsset) const;
	class UDataLayerInstance* GetDataLayerInstanceFromAsset(const class UDataLayerAsset* InDataLayerAsset) const;
	EDataLayerRuntimeState GetDataLayerInstanceRuntimeState(const class UDataLayerAsset* InDataLayerAsset) const;
	EDataLayerRuntimeState GetDataLayerRuntimeState(const struct FActorDataLayer& InDataLayer) const;
	EDataLayerRuntimeState GetDataLayerRuntimeStateByLabel(const class FName& InDataLayerLabel) const;
	EDataLayerState GetDataLayerState(const struct FActorDataLayer& InDataLayer) const;
	EDataLayerState GetDataLayerStateByLabel(const class FName& InDataLayerLabel) const;
	const TSet<class FName> GetLoadedDataLayerNames() const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"DataLayerSubsystem">();
	}
	static class UDataLayerSubsystem* GetDefaultObj()
	{
		return GetDefaultObjImpl<UDataLayerSubsystem>();
	}
};
static_assert(alignof(UDataLayerSubsystem) == 0x000008, "Wrong alignment on UDataLayerSubsystem");
static_assert(sizeof(UDataLayerSubsystem) == 0x000068, "Wrong size on UDataLayerSubsystem");
static_assert(offsetof(UDataLayerSubsystem, OnDataLayerRuntimeStateChanged) == 0x000030, "Member 'UDataLayerSubsystem::OnDataLayerRuntimeStateChanged' has a wrong offset!");
static_assert(offsetof(UDataLayerSubsystem, DataLayerLoadingPolicyClass) == 0x000040, "Member 'UDataLayerSubsystem::DataLayerLoadingPolicyClass' has a wrong offset!");

// Class Engine.WorldPartitionDestructibleHLODComponent
// 0x0010 (0x02B0 - 0x02A0)
class UWorldPartitionDestructibleHLODComponent : public USceneComponent
{
public:
	TArray<class FName>                           DestructibleActors;                                // 0x02A0(0x0010)(ZeroConstructor, Protected, NativeAccessSpecifierProtected)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"WorldPartitionDestructibleHLODComponent">();
	}
	static class UWorldPartitionDestructibleHLODComponent* GetDefaultObj()
	{
		return GetDefaultObjImpl<UWorldPartitionDestructibleHLODComponent>();
	}
};
static_assert(alignof(UWorldPartitionDestructibleHLODComponent) == 0x000010, "Wrong alignment on UWorldPartitionDestructibleHLODComponent");
static_assert(sizeof(UWorldPartitionDestructibleHLODComponent) == 0x0002B0, "Wrong size on UWorldPartitionDestructibleHLODComponent");
static_assert(offsetof(UWorldPartitionDestructibleHLODComponent, DestructibleActors) == 0x0002A0, "Member 'UWorldPartitionDestructibleHLODComponent::DestructibleActors' has a wrong offset!");

// Class Engine.WorldPartitionDestructibleHLODMeshComponent
// 0x0160 (0x0410 - 0x02B0)
class UWorldPartitionDestructibleHLODMeshComponent final : public UWorldPartitionDestructibleHLODComponent
{
public:
	class UMaterialInterface*                     DestructibleHLODMaterial;                          // 0x02B0(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	struct FWorldPartitionDestructibleHLODState   DestructibleHLODState;                             // 0x02B8(0x0148)(Net, Transient, ContainsInstancedReference, NativeAccessSpecifierPrivate)
	class UMaterialInstanceDynamic*               VisibilityMaterial;                                // 0x0400(0x0008)(ZeroConstructor, Transient, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	class UTexture2DDynamic*                      VisibilityTexture;                                 // 0x0408(0x0008)(ZeroConstructor, Transient, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"WorldPartitionDestructibleHLODMeshComponent">();
	}
	static class UWorldPartitionDestructibleHLODMeshComponent* GetDefaultObj()
	{
		return GetDefaultObjImpl<UWorldPartitionDestructibleHLODMeshComponent>();
	}
};
static_assert(alignof(UWorldPartitionDestructibleHLODMeshComponent) == 0x000010, "Wrong alignment on UWorldPartitionDestructibleHLODMeshComponent");
static_assert(sizeof(UWorldPartitionDestructibleHLODMeshComponent) == 0x000410, "Wrong size on UWorldPartitionDestructibleHLODMeshComponent");
static_assert(offsetof(UWorldPartitionDestructibleHLODMeshComponent, DestructibleHLODMaterial) == 0x0002B0, "Member 'UWorldPartitionDestructibleHLODMeshComponent::DestructibleHLODMaterial' has a wrong offset!");
static_assert(offsetof(UWorldPartitionDestructibleHLODMeshComponent, DestructibleHLODState) == 0x0002B8, "Member 'UWorldPartitionDestructibleHLODMeshComponent::DestructibleHLODState' has a wrong offset!");
static_assert(offsetof(UWorldPartitionDestructibleHLODMeshComponent, VisibilityMaterial) == 0x000400, "Member 'UWorldPartitionDestructibleHLODMeshComponent::VisibilityMaterial' has a wrong offset!");
static_assert(offsetof(UWorldPartitionDestructibleHLODMeshComponent, VisibilityTexture) == 0x000408, "Member 'UWorldPartitionDestructibleHLODMeshComponent::VisibilityTexture' has a wrong offset!");

// Class Engine.WorldPartitionHLOD
// 0x0018 (0x02B8 - 0x02A0)
class AWorldPartitionHLOD final : public AActor
{
public:
	uint32                                        LODLevel;                                          // 0x02A0(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	bool                                          bRequireWarmup;                                    // 0x02A4(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_2A5[0x3];                                      // 0x02A5(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	struct FGuid                                  SourceCellGuid;                                    // 0x02A8(0x0010)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"WorldPartitionHLOD">();
	}
	static class AWorldPartitionHLOD* GetDefaultObj()
	{
		return GetDefaultObjImpl<AWorldPartitionHLOD>();
	}
};
static_assert(alignof(AWorldPartitionHLOD) == 0x000008, "Wrong alignment on AWorldPartitionHLOD");
static_assert(sizeof(AWorldPartitionHLOD) == 0x0002B8, "Wrong size on AWorldPartitionHLOD");
static_assert(offsetof(AWorldPartitionHLOD, LODLevel) == 0x0002A0, "Member 'AWorldPartitionHLOD::LODLevel' has a wrong offset!");
static_assert(offsetof(AWorldPartitionHLOD, bRequireWarmup) == 0x0002A4, "Member 'AWorldPartitionHLOD::bRequireWarmup' has a wrong offset!");
static_assert(offsetof(AWorldPartitionHLOD, SourceCellGuid) == 0x0002A8, "Member 'AWorldPartitionHLOD::SourceCellGuid' has a wrong offset!");

// Class Engine.NullHLODBuilder
// 0x0000 (0x0028 - 0x0028)
class UNullHLODBuilder final : public UHLODBuilder
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"NullHLODBuilder">();
	}
	static class UNullHLODBuilder* GetDefaultObj()
	{
		return GetDefaultObjImpl<UNullHLODBuilder>();
	}
};
static_assert(alignof(UNullHLODBuilder) == 0x000008, "Wrong alignment on UNullHLODBuilder");
static_assert(sizeof(UNullHLODBuilder) == 0x000028, "Wrong size on UNullHLODBuilder");

// Class Engine.WorldPartitionDestructibleInHLODInterface
// 0x0000 (0x0000 - 0x0000)
class IWorldPartitionDestructibleInHLODInterface final
{
public:
	void SetHLODDestructionTag(const struct FWorldPartitionHLODDestructionTag& InDestructionTag);

	struct FWorldPartitionHLODDestructionTag GetHLODDestructionTag() const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"WorldPartitionDestructibleInHLODInterface">();
	}
	static class IWorldPartitionDestructibleInHLODInterface* GetDefaultObj()
	{
		return GetDefaultObjImpl<IWorldPartitionDestructibleInHLODInterface>();
	}

	class UObject* AsUObject()
	{
		return reinterpret_cast<UObject*>(this);
	}
	const class UObject* AsUObject() const
	{
		return reinterpret_cast<const UObject*>(this);
	}
};
static_assert(alignof(IWorldPartitionDestructibleInHLODInterface) == 0x000001, "Wrong alignment on IWorldPartitionDestructibleInHLODInterface");
static_assert(sizeof(IWorldPartitionDestructibleInHLODInterface) == 0x000001, "Wrong size on IWorldPartitionDestructibleInHLODInterface");

// Class Engine.WorldPartitionDestructibleInHLODSupportLibrary
// 0x0000 (0x0028 - 0x0028)
class UWorldPartitionDestructibleInHLODSupportLibrary final : public UBlueprintFunctionLibrary
{
public:
	static void DamageInHLOD(const TScriptInterface<class IWorldPartitionDestructibleInHLODInterface>& DestructibleInHLOD, float DamagePercent);
	static void DestroyInHLOD(const TScriptInterface<class IWorldPartitionDestructibleInHLODInterface>& DestructibleInHLOD);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"WorldPartitionDestructibleInHLODSupportLibrary">();
	}
	static class UWorldPartitionDestructibleInHLODSupportLibrary* GetDefaultObj()
	{
		return GetDefaultObjImpl<UWorldPartitionDestructibleInHLODSupportLibrary>();
	}
};
static_assert(alignof(UWorldPartitionDestructibleInHLODSupportLibrary) == 0x000008, "Wrong alignment on UWorldPartitionDestructibleInHLODSupportLibrary");
static_assert(sizeof(UWorldPartitionDestructibleInHLODSupportLibrary) == 0x000028, "Wrong size on UWorldPartitionDestructibleInHLODSupportLibrary");

// Class Engine.WorldPartitionHLODModifier
// 0x0000 (0x0028 - 0x0028)
class UWorldPartitionHLODModifier final : public UObject
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"WorldPartitionHLODModifier">();
	}
	static class UWorldPartitionHLODModifier* GetDefaultObj()
	{
		return GetDefaultObjImpl<UWorldPartitionHLODModifier>();
	}
};
static_assert(alignof(UWorldPartitionHLODModifier) == 0x000008, "Wrong alignment on UWorldPartitionHLODModifier");
static_assert(sizeof(UWorldPartitionHLODModifier) == 0x000028, "Wrong size on UWorldPartitionHLODModifier");

// Class Engine.HLODSubsystem
// 0x0120 (0x0150 - 0x0030)
class UHLODSubsystem final : public UWorldSubsystem
{
public:
	uint8                                         Pad_30[0x120];                                     // 0x0030(0x0120)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"HLODSubsystem">();
	}
	static class UHLODSubsystem* GetDefaultObj()
	{
		return GetDefaultObjImpl<UHLODSubsystem>();
	}
};
static_assert(alignof(UHLODSubsystem) == 0x000008, "Wrong alignment on UHLODSubsystem");
static_assert(sizeof(UHLODSubsystem) == 0x000150, "Wrong size on UHLODSubsystem");

// Class Engine.NavigationDataChunkActor
// 0x0048 (0x02E8 - 0x02A0)
class ANavigationDataChunkActor final : public APartitionActor
{
public:
	TArray<class UNavigationDataChunk*>           NavDataChunks;                                     // 0x02A0(0x0010)(ZeroConstructor, Protected, UObjectWrapper, NativeAccessSpecifierProtected)
	struct FBox                                   DataChunkActorBounds;                              // 0x02B0(0x0038)(ZeroConstructor, IsPlainOldData, NoDestructor, Protected, NativeAccessSpecifierProtected)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"NavigationDataChunkActor">();
	}
	static class ANavigationDataChunkActor* GetDefaultObj()
	{
		return GetDefaultObjImpl<ANavigationDataChunkActor>();
	}
};
static_assert(alignof(ANavigationDataChunkActor) == 0x000008, "Wrong alignment on ANavigationDataChunkActor");
static_assert(sizeof(ANavigationDataChunkActor) == 0x0002E8, "Wrong size on ANavigationDataChunkActor");
static_assert(offsetof(ANavigationDataChunkActor, NavDataChunks) == 0x0002A0, "Member 'ANavigationDataChunkActor::NavDataChunks' has a wrong offset!");
static_assert(offsetof(ANavigationDataChunkActor, DataChunkActorBounds) == 0x0002B0, "Member 'ANavigationDataChunkActor::DataChunkActorBounds' has a wrong offset!");

// Class Engine.WorldPartitionActorLoaderInterface
// 0x0000 (0x0000 - 0x0000)
class IWorldPartitionActorLoaderInterface final
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"WorldPartitionActorLoaderInterface">();
	}
	static class IWorldPartitionActorLoaderInterface* GetDefaultObj()
	{
		return GetDefaultObjImpl<IWorldPartitionActorLoaderInterface>();
	}

	class UObject* AsUObject()
	{
		return reinterpret_cast<UObject*>(this);
	}
	const class UObject* AsUObject() const
	{
		return reinterpret_cast<const UObject*>(this);
	}
};
static_assert(alignof(IWorldPartitionActorLoaderInterface) == 0x000001, "Wrong alignment on IWorldPartitionActorLoaderInterface");
static_assert(sizeof(IWorldPartitionActorLoaderInterface) == 0x000001, "Wrong size on IWorldPartitionActorLoaderInterface");

// Class Engine.WorldPartitionLevelStreamingDynamic
// 0x0020 (0x01C0 - 0x01A0)
class UWorldPartitionLevelStreamingDynamic final : public ULevelStreamingDynamic
{
public:
	bool                                          bShouldBeAlwaysLoaded;                             // 0x01A0(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_1A1[0x3];                                      // 0x01A1(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	TWeakObjectPtr<class UWorldPartitionRuntimeLevelStreamingCell> StreamingCell;                    // 0x01A4(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_1AC[0x4];                                      // 0x01AC(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	class UWorldPartition*                        OuterWorldPartition;                               // 0x01B0(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_1B8[0x8];                                      // 0x01B8(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"WorldPartitionLevelStreamingDynamic">();
	}
	static class UWorldPartitionLevelStreamingDynamic* GetDefaultObj()
	{
		return GetDefaultObjImpl<UWorldPartitionLevelStreamingDynamic>();
	}
};
static_assert(alignof(UWorldPartitionLevelStreamingDynamic) == 0x000010, "Wrong alignment on UWorldPartitionLevelStreamingDynamic");
static_assert(sizeof(UWorldPartitionLevelStreamingDynamic) == 0x0001C0, "Wrong size on UWorldPartitionLevelStreamingDynamic");
static_assert(offsetof(UWorldPartitionLevelStreamingDynamic, bShouldBeAlwaysLoaded) == 0x0001A0, "Member 'UWorldPartitionLevelStreamingDynamic::bShouldBeAlwaysLoaded' has a wrong offset!");
static_assert(offsetof(UWorldPartitionLevelStreamingDynamic, StreamingCell) == 0x0001A4, "Member 'UWorldPartitionLevelStreamingDynamic::StreamingCell' has a wrong offset!");
static_assert(offsetof(UWorldPartitionLevelStreamingDynamic, OuterWorldPartition) == 0x0001B0, "Member 'UWorldPartitionLevelStreamingDynamic::OuterWorldPartition' has a wrong offset!");

// Class Engine.WorldPartitionLevelStreamingPolicy
// 0x0070 (0x02F8 - 0x0288)
class UWorldPartitionLevelStreamingPolicy final : public UWorldPartitionStreamingPolicy
{
public:
	struct FTopLevelAssetPath                     SourceWorldAssetPath;                              // 0x0288(0x0010)(NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	TMap<class FName, class FName>                SubObjectsToCellRemapping;                         // 0x0298(0x0050)(NativeAccessSpecifierPrivate)
	TArray<TWeakObjectPtr<class URuntimeHashExternalStreamingObjectBase>> ExternalStreamingObjects;  // 0x02E8(0x0010)(ZeroConstructor, Transient, UObjectWrapper, NativeAccessSpecifierPrivate)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"WorldPartitionLevelStreamingPolicy">();
	}
	static class UWorldPartitionLevelStreamingPolicy* GetDefaultObj()
	{
		return GetDefaultObjImpl<UWorldPartitionLevelStreamingPolicy>();
	}
};
static_assert(alignof(UWorldPartitionLevelStreamingPolicy) == 0x000008, "Wrong alignment on UWorldPartitionLevelStreamingPolicy");
static_assert(sizeof(UWorldPartitionLevelStreamingPolicy) == 0x0002F8, "Wrong size on UWorldPartitionLevelStreamingPolicy");
static_assert(offsetof(UWorldPartitionLevelStreamingPolicy, SourceWorldAssetPath) == 0x000288, "Member 'UWorldPartitionLevelStreamingPolicy::SourceWorldAssetPath' has a wrong offset!");
static_assert(offsetof(UWorldPartitionLevelStreamingPolicy, SubObjectsToCellRemapping) == 0x000298, "Member 'UWorldPartitionLevelStreamingPolicy::SubObjectsToCellRemapping' has a wrong offset!");
static_assert(offsetof(UWorldPartitionLevelStreamingPolicy, ExternalStreamingObjects) == 0x0002E8, "Member 'UWorldPartitionLevelStreamingPolicy::ExternalStreamingObjects' has a wrong offset!");

// Class Engine.WorldPartitionMiniMap
// 0x00D0 (0x0370 - 0x02A0)
class AWorldPartitionMiniMap final : public AInfo
{
public:
	struct FBox                                   MiniMapWorldBounds;                                // 0x02A0(0x0038)(Edit, ZeroConstructor, EditConst, IsPlainOldData, NoDestructor, AdvancedDisplay, NativeAccessSpecifierPublic)
	struct FBox2D                                 UVOffset;                                          // 0x02D8(0x0028)(Edit, ZeroConstructor, EditConst, IsPlainOldData, NoDestructor, AdvancedDisplay, NativeAccessSpecifierPublic)
	class UTexture2D*                             MiniMapTexture;                                    // 0x0300(0x0008)(Edit, ZeroConstructor, EditConst, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TSet<struct FActorDataLayer>                  ExcludedDataLayers;                                // 0x0308(0x0050)(Edit, NativeAccessSpecifierPublic)
	int32                                         WorldUnitsPerPixel;                                // 0x0358(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         BuilderCellSize;                                   // 0x035C(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	ESceneCaptureSource                           CaptureSource;                                     // 0x0360(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_361[0x3];                                      // 0x0361(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	uint32                                        CaptureWarmupFrames;                               // 0x0364(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         MiniMapTileSize;                                   // 0x0368(0x0004)(ZeroConstructor, Deprecated, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_36C[0x4];                                      // 0x036C(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"WorldPartitionMiniMap">();
	}
	static class AWorldPartitionMiniMap* GetDefaultObj()
	{
		return GetDefaultObjImpl<AWorldPartitionMiniMap>();
	}
};
static_assert(alignof(AWorldPartitionMiniMap) == 0x000008, "Wrong alignment on AWorldPartitionMiniMap");
static_assert(sizeof(AWorldPartitionMiniMap) == 0x000370, "Wrong size on AWorldPartitionMiniMap");
static_assert(offsetof(AWorldPartitionMiniMap, MiniMapWorldBounds) == 0x0002A0, "Member 'AWorldPartitionMiniMap::MiniMapWorldBounds' has a wrong offset!");
static_assert(offsetof(AWorldPartitionMiniMap, UVOffset) == 0x0002D8, "Member 'AWorldPartitionMiniMap::UVOffset' has a wrong offset!");
static_assert(offsetof(AWorldPartitionMiniMap, MiniMapTexture) == 0x000300, "Member 'AWorldPartitionMiniMap::MiniMapTexture' has a wrong offset!");
static_assert(offsetof(AWorldPartitionMiniMap, ExcludedDataLayers) == 0x000308, "Member 'AWorldPartitionMiniMap::ExcludedDataLayers' has a wrong offset!");
static_assert(offsetof(AWorldPartitionMiniMap, WorldUnitsPerPixel) == 0x000358, "Member 'AWorldPartitionMiniMap::WorldUnitsPerPixel' has a wrong offset!");
static_assert(offsetof(AWorldPartitionMiniMap, BuilderCellSize) == 0x00035C, "Member 'AWorldPartitionMiniMap::BuilderCellSize' has a wrong offset!");
static_assert(offsetof(AWorldPartitionMiniMap, CaptureSource) == 0x000360, "Member 'AWorldPartitionMiniMap::CaptureSource' has a wrong offset!");
static_assert(offsetof(AWorldPartitionMiniMap, CaptureWarmupFrames) == 0x000364, "Member 'AWorldPartitionMiniMap::CaptureWarmupFrames' has a wrong offset!");
static_assert(offsetof(AWorldPartitionMiniMap, MiniMapTileSize) == 0x000368, "Member 'AWorldPartitionMiniMap::MiniMapTileSize' has a wrong offset!");

// Class Engine.WorldPartitionMiniMapVolume
// 0x0000 (0x02D8 - 0x02D8)
class AWorldPartitionMiniMapVolume final : public AVolume
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"WorldPartitionMiniMapVolume">();
	}
	static class AWorldPartitionMiniMapVolume* GetDefaultObj()
	{
		return GetDefaultObjImpl<AWorldPartitionMiniMapVolume>();
	}
};
static_assert(alignof(AWorldPartitionMiniMapVolume) == 0x000008, "Wrong alignment on AWorldPartitionMiniMapVolume");
static_assert(sizeof(AWorldPartitionMiniMapVolume) == 0x0002D8, "Wrong size on AWorldPartitionMiniMapVolume");

// Class Engine.WorldPartitionReplay
// 0x0020 (0x02C0 - 0x02A0)
class AWorldPartitionReplay final : public AActor
{
public:
	TArray<class FName>                           StreamingSourceNames;                              // 0x02A0(0x0010)(Net, ZeroConstructor, Transient, NativeAccessSpecifierPrivate)
	uint8                                         Pad_2B0[0x10];                                     // 0x02B0(0x0010)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"WorldPartitionReplay">();
	}
	static class AWorldPartitionReplay* GetDefaultObj()
	{
		return GetDefaultObjImpl<AWorldPartitionReplay>();
	}
};
static_assert(alignof(AWorldPartitionReplay) == 0x000008, "Wrong alignment on AWorldPartitionReplay");
static_assert(sizeof(AWorldPartitionReplay) == 0x0002C0, "Wrong size on AWorldPartitionReplay");
static_assert(offsetof(AWorldPartitionReplay, StreamingSourceNames) == 0x0002A0, "Member 'AWorldPartitionReplay::StreamingSourceNames' has a wrong offset!");

// Class Engine.WorldPartitionCell
// 0x0000 (0x0000 - 0x0000)
class IWorldPartitionCell final
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"WorldPartitionCell">();
	}
	static class IWorldPartitionCell* GetDefaultObj()
	{
		return GetDefaultObjImpl<IWorldPartitionCell>();
	}

	class UObject* AsUObject()
	{
		return reinterpret_cast<UObject*>(this);
	}
	const class UObject* AsUObject() const
	{
		return reinterpret_cast<const UObject*>(this);
	}
};
static_assert(alignof(IWorldPartitionCell) == 0x000001, "Wrong alignment on IWorldPartitionCell");
static_assert(sizeof(IWorldPartitionCell) == 0x000001, "Wrong size on IWorldPartitionCell");

// Class Engine.SpatialHashRuntimeGridInfo
// 0x0008 (0x02A8 - 0x02A0)
class ASpatialHashRuntimeGridInfo final : public AInfo
{
public:
	struct FSpatialHashRuntimeGrid                GridSettings;                                      // 0x02A0(0x0001)(NoDestructor, NativeAccessSpecifierPublic)
	uint8                                         Pad_2A1[0x7];                                      // 0x02A1(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"SpatialHashRuntimeGridInfo">();
	}
	static class ASpatialHashRuntimeGridInfo* GetDefaultObj()
	{
		return GetDefaultObjImpl<ASpatialHashRuntimeGridInfo>();
	}
};
static_assert(alignof(ASpatialHashRuntimeGridInfo) == 0x000008, "Wrong alignment on ASpatialHashRuntimeGridInfo");
static_assert(sizeof(ASpatialHashRuntimeGridInfo) == 0x0002A8, "Wrong size on ASpatialHashRuntimeGridInfo");
static_assert(offsetof(ASpatialHashRuntimeGridInfo, GridSettings) == 0x0002A0, "Member 'ASpatialHashRuntimeGridInfo::GridSettings' has a wrong offset!");

// Class Engine.RuntimeSpatialHashExternalStreamingObject
// 0x0010 (0x0128 - 0x0118)
class URuntimeSpatialHashExternalStreamingObject final : public URuntimeHashExternalStreamingObjectBase
{
public:
	TArray<struct FSpatialHashStreamingGrid>      StreamingGrids;                                    // 0x0118(0x0010)(ZeroConstructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"RuntimeSpatialHashExternalStreamingObject">();
	}
	static class URuntimeSpatialHashExternalStreamingObject* GetDefaultObj()
	{
		return GetDefaultObjImpl<URuntimeSpatialHashExternalStreamingObject>();
	}
};
static_assert(alignof(URuntimeSpatialHashExternalStreamingObject) == 0x000008, "Wrong alignment on URuntimeSpatialHashExternalStreamingObject");
static_assert(sizeof(URuntimeSpatialHashExternalStreamingObject) == 0x000128, "Wrong size on URuntimeSpatialHashExternalStreamingObject");
static_assert(offsetof(URuntimeSpatialHashExternalStreamingObject, StreamingGrids) == 0x000118, "Member 'URuntimeSpatialHashExternalStreamingObject::StreamingGrids' has a wrong offset!");

// Class Engine.WorldPartitionRuntimeSpatialHash
// 0x0070 (0x00E8 - 0x0078)
class UWorldPartitionRuntimeSpatialHash final : public UWorldPartitionRuntimeHash
{
public:
	EWorldPartitionCVarProjectDefaultOverride     UseAlignedGridLevels;                              // 0x0078(0x0001)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	EWorldPartitionCVarProjectDefaultOverride     SnapNonAlignedGridLevelsToLowerLevels;             // 0x0079(0x0001)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	EWorldPartitionCVarProjectDefaultOverride     PlaceSmallActorsUsingLocation;                     // 0x007A(0x0001)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	EWorldPartitionCVarProjectDefaultOverride     PlacePartitionActorsUsingLocation;                 // 0x007B(0x0001)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	bool                                          bEnableZCulling;                                   // 0x007C(0x0001)(Edit, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_7D[0x3];                                       // 0x007D(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<struct FSpatialHashStreamingGrid>      StreamingGrids;                                    // 0x0080(0x0010)(ZeroConstructor, Protected, NonPIEDuplicateTransient, NativeAccessSpecifierProtected)
	uint8                                         Pad_90[0x58];                                      // 0x0090(0x0058)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"WorldPartitionRuntimeSpatialHash">();
	}
	static class UWorldPartitionRuntimeSpatialHash* GetDefaultObj()
	{
		return GetDefaultObjImpl<UWorldPartitionRuntimeSpatialHash>();
	}
};
static_assert(alignof(UWorldPartitionRuntimeSpatialHash) == 0x000008, "Wrong alignment on UWorldPartitionRuntimeSpatialHash");
static_assert(sizeof(UWorldPartitionRuntimeSpatialHash) == 0x0000E8, "Wrong size on UWorldPartitionRuntimeSpatialHash");
static_assert(offsetof(UWorldPartitionRuntimeSpatialHash, UseAlignedGridLevels) == 0x000078, "Member 'UWorldPartitionRuntimeSpatialHash::UseAlignedGridLevels' has a wrong offset!");
static_assert(offsetof(UWorldPartitionRuntimeSpatialHash, SnapNonAlignedGridLevelsToLowerLevels) == 0x000079, "Member 'UWorldPartitionRuntimeSpatialHash::SnapNonAlignedGridLevelsToLowerLevels' has a wrong offset!");
static_assert(offsetof(UWorldPartitionRuntimeSpatialHash, PlaceSmallActorsUsingLocation) == 0x00007A, "Member 'UWorldPartitionRuntimeSpatialHash::PlaceSmallActorsUsingLocation' has a wrong offset!");
static_assert(offsetof(UWorldPartitionRuntimeSpatialHash, PlacePartitionActorsUsingLocation) == 0x00007B, "Member 'UWorldPartitionRuntimeSpatialHash::PlacePartitionActorsUsingLocation' has a wrong offset!");
static_assert(offsetof(UWorldPartitionRuntimeSpatialHash, bEnableZCulling) == 0x00007C, "Member 'UWorldPartitionRuntimeSpatialHash::bEnableZCulling' has a wrong offset!");
static_assert(offsetof(UWorldPartitionRuntimeSpatialHash, StreamingGrids) == 0x000080, "Member 'UWorldPartitionRuntimeSpatialHash::StreamingGrids' has a wrong offset!");

// Class Engine.WorldPartitionSubsystem
// 0x0290 (0x02D0 - 0x0040)
class UWorldPartitionSubsystem final : public UTickableWorldSubsystem
{
public:
	uint8                                         Pad_40[0x290];                                     // 0x0040(0x0290)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	bool IsAllStreamingCompleted();

	bool IsStreamingCompleted(EWorldPartitionRuntimeCellState QueryState, const TArray<struct FWorldPartitionStreamingQuerySource>& QuerySources, bool bExactState) const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"WorldPartitionSubsystem">();
	}
	static class UWorldPartitionSubsystem* GetDefaultObj()
	{
		return GetDefaultObjImpl<UWorldPartitionSubsystem>();
	}
};
static_assert(alignof(UWorldPartitionSubsystem) == 0x000008, "Wrong alignment on UWorldPartitionSubsystem");
static_assert(sizeof(UWorldPartitionSubsystem) == 0x0002D0, "Wrong size on UWorldPartitionSubsystem");

}

