#pragma once

// Dumped with Dumper-7!


#include "../SDK.hpp"

namespace SDK
{
//---------------------------------------------------------------------------------------------------------------------
// FUNCTIONS
//---------------------------------------------------------------------------------------------------------------------


// Class Water.BuoyancyComponent
// (None)

class UClass* UBuoyancyComponent::StaticClass()
{
	static class UClass* Clss = nullptr;

	if (!Clss)
		Clss = UObject::FindClassFast("BuoyancyComponent");

	return Clss;
}


// BuoyancyComponent Water.Default__BuoyancyComponent
// (Public, ClassDefaultObject, ArchetypeObject)

class UBuoyancyComponent* UBuoyancyComponent::GetDefaultObj()
{
	static class UBuoyancyComponent* Default = nullptr;

	if (!Default)
		Default = static_cast<UBuoyancyComponent*>(UBuoyancyComponent::StaticClass()->DefaultObject);

	return Default;
}


// Function Water.BuoyancyComponent.OnPontoonExitedWater
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// struct FSphericalPontoon           Pontoon                                                          (ConstParm, Parm, OutParm, ReferenceParm, ContainsInstancedReference, NativeAccessSpecifierPublic)

void UBuoyancyComponent::OnPontoonExitedWater(struct FSphericalPontoon& Pontoon)
{
	static class UFunction* Func = nullptr;

	if (!Func)
		Func = Class->GetFunction("BuoyancyComponent", "OnPontoonExitedWater");

	Params::UBuoyancyComponent_OnPontoonExitedWater_Params Parms{};

	Parms.Pontoon = Pontoon;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);


	Func->FunctionFlags = Flgs;

}


// Function Water.BuoyancyComponent.OnPontoonEnteredWater
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// struct FSphericalPontoon           Pontoon                                                          (ConstParm, Parm, OutParm, ReferenceParm, ContainsInstancedReference, NativeAccessSpecifierPublic)

void UBuoyancyComponent::OnPontoonEnteredWater(struct FSphericalPontoon& Pontoon)
{
	static class UFunction* Func = nullptr;

	if (!Func)
		Func = Class->GetFunction("BuoyancyComponent", "OnPontoonEnteredWater");

	Params::UBuoyancyComponent_OnPontoonEnteredWater_Params Parms{};

	Parms.Pontoon = Pontoon;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);


	Func->FunctionFlags = Flgs;

}


// Function Water.BuoyancyComponent.IsOverlappingWaterBody
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                               ReturnValue                                                      (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UBuoyancyComponent::IsOverlappingWaterBody()
{
	static class UFunction* Func = nullptr;

	if (!Func)
		Func = Class->GetFunction("BuoyancyComponent", "IsOverlappingWaterBody");

	Params::UBuoyancyComponent_IsOverlappingWaterBody_Params Parms{};


	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);


	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;

}


// Function Water.BuoyancyComponent.IsInWaterBody
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                               ReturnValue                                                      (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UBuoyancyComponent::IsInWaterBody()
{
	static class UFunction* Func = nullptr;

	if (!Func)
		Func = Class->GetFunction("BuoyancyComponent", "IsInWaterBody");

	Params::UBuoyancyComponent_IsInWaterBody_Params Parms{};


	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);


	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;

}


// Function Water.BuoyancyComponent.GetLastWaterSurfaceInfo
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// struct FVector                     OutWaterPlaneLocation                                            (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector                     OutWaterPlaneNormal                                              (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector                     OutWaterSurfacePosition                                          (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                              OutWaterDepth                                                    (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                              OutWaterBodyIdx                                                  (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector                     OutWaterVelocity                                                 (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBuoyancyComponent::GetLastWaterSurfaceInfo(struct FVector* OutWaterPlaneLocation, struct FVector* OutWaterPlaneNormal, struct FVector* OutWaterSurfacePosition, float* OutWaterDepth, int32* OutWaterBodyIdx, struct FVector* OutWaterVelocity)
{
	static class UFunction* Func = nullptr;

	if (!Func)
		Func = Class->GetFunction("BuoyancyComponent", "GetLastWaterSurfaceInfo");

	Params::UBuoyancyComponent_GetLastWaterSurfaceInfo_Params Parms{};


	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);


	Func->FunctionFlags = Flgs;

	if (OutWaterPlaneLocation != nullptr)
		*OutWaterPlaneLocation = std::move(Parms.OutWaterPlaneLocation);

	if (OutWaterPlaneNormal != nullptr)
		*OutWaterPlaneNormal = std::move(Parms.OutWaterPlaneNormal);

	if (OutWaterSurfacePosition != nullptr)
		*OutWaterSurfacePosition = std::move(Parms.OutWaterSurfacePosition);

	if (OutWaterDepth != nullptr)
		*OutWaterDepth = Parms.OutWaterDepth;

	if (OutWaterBodyIdx != nullptr)
		*OutWaterBodyIdx = Parms.OutWaterBodyIdx;

	if (OutWaterVelocity != nullptr)
		*OutWaterVelocity = std::move(Parms.OutWaterVelocity);

}


// Function Water.BuoyancyComponent.GetCurrentWaterBodyComponents
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TArray<class UWaterBodyComponent*> ReturnValue                                                      (ConstParm, ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, ReferenceParm, ContainsInstancedReference, NativeAccessSpecifierPublic)

TArray<class UWaterBodyComponent*> UBuoyancyComponent::GetCurrentWaterBodyComponents()
{
	static class UFunction* Func = nullptr;

	if (!Func)
		Func = Class->GetFunction("BuoyancyComponent", "GetCurrentWaterBodyComponents");

	Params::UBuoyancyComponent_GetCurrentWaterBodyComponents_Params Parms{};


	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);


	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;

}


// Class Water.BuoyancyManager
// (Actor)

class UClass* ABuoyancyManager::StaticClass()
{
	static class UClass* Clss = nullptr;

	if (!Clss)
		Clss = UObject::FindClassFast("BuoyancyManager");

	return Clss;
}


// BuoyancyManager Water.Default__BuoyancyManager
// (Public, ClassDefaultObject, ArchetypeObject)

class ABuoyancyManager* ABuoyancyManager::GetDefaultObj()
{
	static class ABuoyancyManager* Default = nullptr;

	if (!Default)
		Default = static_cast<ABuoyancyManager*>(ABuoyancyManager::StaticClass()->DefaultObject);

	return Default;
}


// Function Water.BuoyancyManager.GetBuoyancyComponentManager
// (Final, Native, Static, Public, HasOutParams)
// Parameters:
// class UObject*                     WorldContextObject                                               (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class ABuoyancyManager*            Manager                                                          (Parm, OutParm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                               ReturnValue                                                      (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool ABuoyancyManager::GetBuoyancyComponentManager(class UObject* WorldContextObject, class ABuoyancyManager** Manager)
{
	static class UFunction* Func = nullptr;

	if (!Func)
		Func = Class->GetFunction("BuoyancyManager", "GetBuoyancyComponentManager");

	Params::ABuoyancyManager_GetBuoyancyComponentManager_Params Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);


	Func->FunctionFlags = Flgs;

	if (Manager != nullptr)
		*Manager = Parms.Manager;

	return Parms.ReturnValue;

}


// Class Water.EnvQueryTest_InsideWaterBody
// (None)

class UClass* UEnvQueryTest_InsideWaterBody::StaticClass()
{
	static class UClass* Clss = nullptr;

	if (!Clss)
		Clss = UObject::FindClassFast("EnvQueryTest_InsideWaterBody");

	return Clss;
}


// EnvQueryTest_InsideWaterBody Water.Default__EnvQueryTest_InsideWaterBody
// (Public, ClassDefaultObject, ArchetypeObject)

class UEnvQueryTest_InsideWaterBody* UEnvQueryTest_InsideWaterBody::GetDefaultObj()
{
	static class UEnvQueryTest_InsideWaterBody* Default = nullptr;

	if (!Default)
		Default = static_cast<UEnvQueryTest_InsideWaterBody*>(UEnvQueryTest_InsideWaterBody::StaticClass()->DefaultObject);

	return Default;
}


// Class Water.GerstnerWaterWaveGeneratorBase
// (None)

class UClass* UGerstnerWaterWaveGeneratorBase::StaticClass()
{
	static class UClass* Clss = nullptr;

	if (!Clss)
		Clss = UObject::FindClassFast("GerstnerWaterWaveGeneratorBase");

	return Clss;
}


// GerstnerWaterWaveGeneratorBase Water.Default__GerstnerWaterWaveGeneratorBase
// (Public, ClassDefaultObject, ArchetypeObject)

class UGerstnerWaterWaveGeneratorBase* UGerstnerWaterWaveGeneratorBase::GetDefaultObj()
{
	static class UGerstnerWaterWaveGeneratorBase* Default = nullptr;

	if (!Default)
		Default = static_cast<UGerstnerWaterWaveGeneratorBase*>(UGerstnerWaterWaveGeneratorBase::StaticClass()->DefaultObject);

	return Default;
}


// Function Water.GerstnerWaterWaveGeneratorBase.GenerateGerstnerWaves
// (Native, Event, Public, HasOutParams, BlueprintEvent, Const)
// Parameters:
// TArray<struct FGerstnerWave>       OutWaves                                                         (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)

void UGerstnerWaterWaveGeneratorBase::GenerateGerstnerWaves(TArray<struct FGerstnerWave>* OutWaves)
{
	static class UFunction* Func = nullptr;

	if (!Func)
		Func = Class->GetFunction("GerstnerWaterWaveGeneratorBase", "GenerateGerstnerWaves");

	Params::UGerstnerWaterWaveGeneratorBase_GenerateGerstnerWaves_Params Parms{};


	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);


	Func->FunctionFlags = Flgs;

	if (OutWaves != nullptr)
		*OutWaves = std::move(Parms.OutWaves);

}


// Class Water.GerstnerWaterWaveGeneratorSimple
// (None)

class UClass* UGerstnerWaterWaveGeneratorSimple::StaticClass()
{
	static class UClass* Clss = nullptr;

	if (!Clss)
		Clss = UObject::FindClassFast("GerstnerWaterWaveGeneratorSimple");

	return Clss;
}


// GerstnerWaterWaveGeneratorSimple Water.Default__GerstnerWaterWaveGeneratorSimple
// (Public, ClassDefaultObject, ArchetypeObject)

class UGerstnerWaterWaveGeneratorSimple* UGerstnerWaterWaveGeneratorSimple::GetDefaultObj()
{
	static class UGerstnerWaterWaveGeneratorSimple* Default = nullptr;

	if (!Default)
		Default = static_cast<UGerstnerWaterWaveGeneratorSimple*>(UGerstnerWaterWaveGeneratorSimple::StaticClass()->DefaultObject);

	return Default;
}


// Class Water.GerstnerWaterWaveGeneratorSpectrum
// (None)

class UClass* UGerstnerWaterWaveGeneratorSpectrum::StaticClass()
{
	static class UClass* Clss = nullptr;

	if (!Clss)
		Clss = UObject::FindClassFast("GerstnerWaterWaveGeneratorSpectrum");

	return Clss;
}


// GerstnerWaterWaveGeneratorSpectrum Water.Default__GerstnerWaterWaveGeneratorSpectrum
// (Public, ClassDefaultObject, ArchetypeObject)

class UGerstnerWaterWaveGeneratorSpectrum* UGerstnerWaterWaveGeneratorSpectrum::GetDefaultObj()
{
	static class UGerstnerWaterWaveGeneratorSpectrum* Default = nullptr;

	if (!Default)
		Default = static_cast<UGerstnerWaterWaveGeneratorSpectrum*>(UGerstnerWaterWaveGeneratorSpectrum::StaticClass()->DefaultObject);

	return Default;
}


// Class Water.WaterWavesBase
// (None)

class UClass* UWaterWavesBase::StaticClass()
{
	static class UClass* Clss = nullptr;

	if (!Clss)
		Clss = UObject::FindClassFast("WaterWavesBase");

	return Clss;
}


// WaterWavesBase Water.Default__WaterWavesBase
// (Public, ClassDefaultObject, ArchetypeObject)

class UWaterWavesBase* UWaterWavesBase::GetDefaultObj()
{
	static class UWaterWavesBase* Default = nullptr;

	if (!Default)
		Default = static_cast<UWaterWavesBase*>(UWaterWavesBase::StaticClass()->DefaultObject);

	return Default;
}


// Class Water.WaterWaves
// (None)

class UClass* UWaterWaves::StaticClass()
{
	static class UClass* Clss = nullptr;

	if (!Clss)
		Clss = UObject::FindClassFast("WaterWaves");

	return Clss;
}


// WaterWaves Water.Default__WaterWaves
// (Public, ClassDefaultObject, ArchetypeObject)

class UWaterWaves* UWaterWaves::GetDefaultObj()
{
	static class UWaterWaves* Default = nullptr;

	if (!Default)
		Default = static_cast<UWaterWaves*>(UWaterWaves::StaticClass()->DefaultObject);

	return Default;
}


// Class Water.GerstnerWaterWaves
// (None)

class UClass* UGerstnerWaterWaves::StaticClass()
{
	static class UClass* Clss = nullptr;

	if (!Clss)
		Clss = UObject::FindClassFast("GerstnerWaterWaves");

	return Clss;
}


// GerstnerWaterWaves Water.Default__GerstnerWaterWaves
// (Public, ClassDefaultObject, ArchetypeObject)

class UGerstnerWaterWaves* UGerstnerWaterWaves::GetDefaultObj()
{
	static class UGerstnerWaterWaves* Default = nullptr;

	if (!Default)
		Default = static_cast<UGerstnerWaterWaves*>(UGerstnerWaterWaves::StaticClass()->DefaultObject);

	return Default;
}


// Class Water.GerstnerWaterWaveSubsystem
// (None)

class UClass* UGerstnerWaterWaveSubsystem::StaticClass()
{
	static class UClass* Clss = nullptr;

	if (!Clss)
		Clss = UObject::FindClassFast("GerstnerWaterWaveSubsystem");

	return Clss;
}


// GerstnerWaterWaveSubsystem Water.Default__GerstnerWaterWaveSubsystem
// (Public, ClassDefaultObject, ArchetypeObject)

class UGerstnerWaterWaveSubsystem* UGerstnerWaterWaveSubsystem::GetDefaultObj()
{
	static class UGerstnerWaterWaveSubsystem* Default = nullptr;

	if (!Default)
		Default = static_cast<UGerstnerWaterWaveSubsystem*>(UGerstnerWaterWaveSubsystem::StaticClass()->DefaultObject);

	return Default;
}


// Class Water.LakeCollisionComponent
// (SceneComponent, PrimitiveComponent)

class UClass* ULakeCollisionComponent::StaticClass()
{
	static class UClass* Clss = nullptr;

	if (!Clss)
		Clss = UObject::FindClassFast("LakeCollisionComponent");

	return Clss;
}


// LakeCollisionComponent Water.Default__LakeCollisionComponent
// (Public, ClassDefaultObject, ArchetypeObject)

class ULakeCollisionComponent* ULakeCollisionComponent::GetDefaultObj()
{
	static class ULakeCollisionComponent* Default = nullptr;

	if (!Default)
		Default = static_cast<ULakeCollisionComponent*>(ULakeCollisionComponent::StaticClass()->DefaultObject);

	return Default;
}


// Class Water.NiagaraDataInterfaceWater
// (None)

class UClass* UNiagaraDataInterfaceWater::StaticClass()
{
	static class UClass* Clss = nullptr;

	if (!Clss)
		Clss = UObject::FindClassFast("NiagaraDataInterfaceWater");

	return Clss;
}


// NiagaraDataInterfaceWater Water.Default__NiagaraDataInterfaceWater
// (Public, ClassDefaultObject, ArchetypeObject)

class UNiagaraDataInterfaceWater* UNiagaraDataInterfaceWater::GetDefaultObj()
{
	static class UNiagaraDataInterfaceWater* Default = nullptr;

	if (!Default)
		Default = static_cast<UNiagaraDataInterfaceWater*>(UNiagaraDataInterfaceWater::StaticClass()->DefaultObject);

	return Default;
}


// Class Water.NiagaraWaterFunctionLibrary
// (None)

class UClass* UNiagaraWaterFunctionLibrary::StaticClass()
{
	static class UClass* Clss = nullptr;

	if (!Clss)
		Clss = UObject::FindClassFast("NiagaraWaterFunctionLibrary");

	return Clss;
}


// NiagaraWaterFunctionLibrary Water.Default__NiagaraWaterFunctionLibrary
// (Public, ClassDefaultObject, ArchetypeObject)

class UNiagaraWaterFunctionLibrary* UNiagaraWaterFunctionLibrary::GetDefaultObj()
{
	static class UNiagaraWaterFunctionLibrary* Default = nullptr;

	if (!Default)
		Default = static_cast<UNiagaraWaterFunctionLibrary*>(UNiagaraWaterFunctionLibrary::StaticClass()->DefaultObject);

	return Default;
}


// Function Water.NiagaraWaterFunctionLibrary.SetWaterBodyComponent
// (Final, Native, Static, Private, BlueprintCallable)
// Parameters:
// class UNiagaraComponent*           NiagaraSystem                                                    (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FString                      OverrideName                                                     (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UWaterBodyComponent*         WaterBodyComponent                                               (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UNiagaraWaterFunctionLibrary::SetWaterBodyComponent(class UNiagaraComponent* NiagaraSystem, const class FString& OverrideName, class UWaterBodyComponent* WaterBodyComponent)
{
	static class UFunction* Func = nullptr;

	if (!Func)
		Func = Class->GetFunction("NiagaraWaterFunctionLibrary", "SetWaterBodyComponent");

	Params::UNiagaraWaterFunctionLibrary_SetWaterBodyComponent_Params Parms{};

	Parms.NiagaraSystem = NiagaraSystem;
	Parms.OverrideName = OverrideName;
	Parms.WaterBodyComponent = WaterBodyComponent;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);


	Func->FunctionFlags = Flgs;

}


// Function Water.NiagaraWaterFunctionLibrary.SetWaterBody
// (Final, Native, Static, Private, BlueprintCallable)
// Parameters:
// class UNiagaraComponent*           NiagaraSystem                                                    (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FString                      OverrideName                                                     (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AWaterBody*                  WaterBody                                                        (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UNiagaraWaterFunctionLibrary::SetWaterBody(class UNiagaraComponent* NiagaraSystem, const class FString& OverrideName, class AWaterBody* WaterBody)
{
	static class UFunction* Func = nullptr;

	if (!Func)
		Func = Class->GetFunction("NiagaraWaterFunctionLibrary", "SetWaterBody");

	Params::UNiagaraWaterFunctionLibrary_SetWaterBody_Params Parms{};

	Parms.NiagaraSystem = NiagaraSystem;
	Parms.OverrideName = OverrideName;
	Parms.WaterBody = WaterBody;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);


	Func->FunctionFlags = Flgs;

}


// Class Water.OceanCollisionComponent
// (SceneComponent, PrimitiveComponent)

class UClass* UOceanCollisionComponent::StaticClass()
{
	static class UClass* Clss = nullptr;

	if (!Clss)
		Clss = UObject::FindClassFast("OceanCollisionComponent");

	return Clss;
}


// OceanCollisionComponent Water.Default__OceanCollisionComponent
// (Public, ClassDefaultObject, ArchetypeObject)

class UOceanCollisionComponent* UOceanCollisionComponent::GetDefaultObj()
{
	static class UOceanCollisionComponent* Default = nullptr;

	if (!Default)
		Default = static_cast<UOceanCollisionComponent*>(UOceanCollisionComponent::StaticClass()->DefaultObject);

	return Default;
}


// Class Water.OceanBoxCollisionComponent
// (SceneComponent, PrimitiveComponent)

class UClass* UOceanBoxCollisionComponent::StaticClass()
{
	static class UClass* Clss = nullptr;

	if (!Clss)
		Clss = UObject::FindClassFast("OceanBoxCollisionComponent");

	return Clss;
}


// OceanBoxCollisionComponent Water.Default__OceanBoxCollisionComponent
// (Public, ClassDefaultObject, ArchetypeObject)

class UOceanBoxCollisionComponent* UOceanBoxCollisionComponent::GetDefaultObj()
{
	static class UOceanBoxCollisionComponent* Default = nullptr;

	if (!Default)
		Default = static_cast<UOceanBoxCollisionComponent*>(UOceanBoxCollisionComponent::StaticClass()->DefaultObject);

	return Default;
}


// Class Water.WaterBody
// (Actor)

class UClass* AWaterBody::StaticClass()
{
	static class UClass* Clss = nullptr;

	if (!Clss)
		Clss = UObject::FindClassFast("WaterBody");

	return Clss;
}


// WaterBody Water.Default__WaterBody
// (Public, ClassDefaultObject, ArchetypeObject)

class AWaterBody* AWaterBody::GetDefaultObj()
{
	static class AWaterBody* Default = nullptr;

	if (!Default)
		Default = static_cast<AWaterBody*>(AWaterBody::StaticClass()->DefaultObject);

	return Default;
}


// Function Water.WaterBody.SetWaterWaves
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UWaterWavesBase*             InWaterWaves                                                     (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AWaterBody::SetWaterWaves(class UWaterWavesBase* InWaterWaves)
{
	static class UFunction* Func = nullptr;

	if (!Func)
		Func = Class->GetFunction("WaterBody", "SetWaterWaves");

	Params::AWaterBody_SetWaterWaves_Params Parms{};

	Parms.InWaterWaves = InWaterWaves;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);


	Func->FunctionFlags = Flgs;

}


// Function Water.WaterBody.SetWaterMaterial
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UMaterialInterface*          InMaterial                                                       (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AWaterBody::SetWaterMaterial(class UMaterialInterface* InMaterial)
{
	static class UFunction* Func = nullptr;

	if (!Func)
		Func = Class->GetFunction("WaterBody", "SetWaterMaterial");

	Params::AWaterBody_SetWaterMaterial_Params Parms{};

	Parms.InMaterial = InMaterial;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);


	Func->FunctionFlags = Flgs;

}


// Function Water.WaterBody.OnWaterBodyChanged
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                               bShapeOrPositionChanged                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                               bWeightmapSettingsChanged                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AWaterBody::OnWaterBodyChanged(bool bShapeOrPositionChanged, bool bWeightmapSettingsChanged)
{
	static class UFunction* Func = nullptr;

	if (!Func)
		Func = Class->GetFunction("WaterBody", "OnWaterBodyChanged");

	Params::AWaterBody_OnWaterBodyChanged_Params Parms{};

	Parms.bShapeOrPositionChanged = bShapeOrPositionChanged;
	Parms.bWeightmapSettingsChanged = bWeightmapSettingsChanged;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);


	Func->FunctionFlags = Flgs;

}


// Function Water.WaterBody.GetWaterVelocityVectorAtSplineInputKey
// (Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                              InKey                                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector                     ReturnValue                                                      (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector AWaterBody::GetWaterVelocityVectorAtSplineInputKey(float InKey)
{
	static class UFunction* Func = nullptr;

	if (!Func)
		Func = Class->GetFunction("WaterBody", "GetWaterVelocityVectorAtSplineInputKey");

	Params::AWaterBody_GetWaterVelocityVectorAtSplineInputKey_Params Parms{};

	Parms.InKey = InKey;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);


	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;

}


// Function Water.WaterBody.GetWaterVelocityAtSplineInputKey
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                              InKey                                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                              ReturnValue                                                      (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float AWaterBody::GetWaterVelocityAtSplineInputKey(float InKey)
{
	static class UFunction* Func = nullptr;

	if (!Func)
		Func = Class->GetFunction("WaterBody", "GetWaterVelocityAtSplineInputKey");

	Params::AWaterBody_GetWaterVelocityAtSplineInputKey_Params Parms{};

	Parms.InKey = InKey;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);


	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;

}


// Function Water.WaterBody.GetWaterSpline
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UWaterSplineComponent*       ReturnValue                                                      (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UWaterSplineComponent* AWaterBody::GetWaterSpline()
{
	static class UFunction* Func = nullptr;

	if (!Func)
		Func = Class->GetFunction("WaterBody", "GetWaterSpline");

	Params::AWaterBody_GetWaterSpline_Params Parms{};


	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);


	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;

}


// Function Water.WaterBody.GetWaterMaterialInstance
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UMaterialInstanceDynamic*    ReturnValue                                                      (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UMaterialInstanceDynamic* AWaterBody::GetWaterMaterialInstance()
{
	static class UFunction* Func = nullptr;

	if (!Func)
		Func = Class->GetFunction("WaterBody", "GetWaterMaterialInstance");

	Params::AWaterBody_GetWaterMaterialInstance_Params Parms{};


	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);


	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;

}


// Function Water.WaterBody.GetWaterBodyType
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// enum class EWaterBodyType          ReturnValue                                                      (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

enum class EWaterBodyType AWaterBody::GetWaterBodyType()
{
	static class UFunction* Func = nullptr;

	if (!Func)
		Func = Class->GetFunction("WaterBody", "GetWaterBodyType");

	Params::AWaterBody_GetWaterBodyType_Params Parms{};


	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);


	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;

}


// Function Water.WaterBody.GetWaterBodyComponent
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UWaterBodyComponent*         ReturnValue                                                      (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UWaterBodyComponent* AWaterBody::GetWaterBodyComponent()
{
	static class UFunction* Func = nullptr;

	if (!Func)
		Func = Class->GetFunction("WaterBody", "GetWaterBodyComponent");

	Params::AWaterBody_GetWaterBodyComponent_Params Parms{};


	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);


	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;

}


// Function Water.WaterBody.GetRiverToOceanTransitionMaterialInstance
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UMaterialInstanceDynamic*    ReturnValue                                                      (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UMaterialInstanceDynamic* AWaterBody::GetRiverToOceanTransitionMaterialInstance()
{
	static class UFunction* Func = nullptr;

	if (!Func)
		Func = Class->GetFunction("WaterBody", "GetRiverToOceanTransitionMaterialInstance");

	Params::AWaterBody_GetRiverToOceanTransitionMaterialInstance_Params Parms{};


	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);


	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;

}


// Function Water.WaterBody.GetRiverToLakeTransitionMaterialInstance
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UMaterialInstanceDynamic*    ReturnValue                                                      (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UMaterialInstanceDynamic* AWaterBody::GetRiverToLakeTransitionMaterialInstance()
{
	static class UFunction* Func = nullptr;

	if (!Func)
		Func = Class->GetFunction("WaterBody", "GetRiverToLakeTransitionMaterialInstance");

	Params::AWaterBody_GetRiverToLakeTransitionMaterialInstance_Params Parms{};


	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);


	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;

}


// Function Water.WaterBody.GetIslands
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TArray<class AWaterBodyIsland*>    ReturnValue                                                      (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<class AWaterBodyIsland*> AWaterBody::GetIslands()
{
	static class UFunction* Func = nullptr;

	if (!Func)
		Func = Class->GetFunction("WaterBody", "GetIslands");

	Params::AWaterBody_GetIslands_Params Parms{};


	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);


	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;

}


// Function Water.WaterBody.GetExclusionVolumes
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TArray<class AWaterBodyExclusionVolume*>ReturnValue                                                      (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<class AWaterBodyExclusionVolume*> AWaterBody::GetExclusionVolumes()
{
	static class UFunction* Func = nullptr;

	if (!Func)
		Func = Class->GetFunction("WaterBody", "GetExclusionVolumes");

	Params::AWaterBody_GetExclusionVolumes_Params Parms{};


	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);


	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;

}


// Function Water.WaterBody.GetAudioIntensityAtSplineInputKey
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                              InKey                                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                              ReturnValue                                                      (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float AWaterBody::GetAudioIntensityAtSplineInputKey(float InKey)
{
	static class UFunction* Func = nullptr;

	if (!Func)
		Func = Class->GetFunction("WaterBody", "GetAudioIntensityAtSplineInputKey");

	Params::AWaterBody_GetAudioIntensityAtSplineInputKey_Params Parms{};

	Parms.InKey = InKey;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);


	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;

}


// Class Water.WaterBodyGenerator
// (None)

class UClass* UWaterBodyGenerator::StaticClass()
{
	static class UClass* Clss = nullptr;

	if (!Clss)
		Clss = UObject::FindClassFast("WaterBodyGenerator");

	return Clss;
}


// WaterBodyGenerator Water.Default__WaterBodyGenerator
// (Public, ClassDefaultObject, ArchetypeObject)

class UWaterBodyGenerator* UWaterBodyGenerator::GetDefaultObj()
{
	static class UWaterBodyGenerator* Default = nullptr;

	if (!Default)
		Default = static_cast<UWaterBodyGenerator*>(UWaterBodyGenerator::StaticClass()->DefaultObject);

	return Default;
}


// Class Water.WaterBodyComponent
// (SceneComponent, PrimitiveComponent)

class UClass* UWaterBodyComponent::StaticClass()
{
	static class UClass* Clss = nullptr;

	if (!Clss)
		Clss = UObject::FindClassFast("WaterBodyComponent");

	return Clss;
}


// WaterBodyComponent Water.Default__WaterBodyComponent
// (Public, ClassDefaultObject, ArchetypeObject)

class UWaterBodyComponent* UWaterBodyComponent::GetDefaultObj()
{
	static class UWaterBodyComponent* Default = nullptr;

	if (!Default)
		Default = static_cast<UWaterBodyComponent*>(UWaterBodyComponent::StaticClass()->DefaultObject);

	return Default;
}


// Function Water.WaterBodyComponent.SetWaterAndUnderWaterPostProcessMaterial
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UMaterialInterface*          InWaterMaterial                                                  (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UMaterialInterface*          InUnderWaterPostProcessMaterial                                  (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UWaterBodyComponent::SetWaterAndUnderWaterPostProcessMaterial(class UMaterialInterface* InWaterMaterial, class UMaterialInterface* InUnderWaterPostProcessMaterial)
{
	static class UFunction* Func = nullptr;

	if (!Func)
		Func = Class->GetFunction("WaterBodyComponent", "SetWaterAndUnderWaterPostProcessMaterial");

	Params::UWaterBodyComponent_SetWaterAndUnderWaterPostProcessMaterial_Params Parms{};

	Parms.InWaterMaterial = InWaterMaterial;
	Parms.InUnderWaterPostProcessMaterial = InUnderWaterPostProcessMaterial;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);


	Func->FunctionFlags = Flgs;

}


// Function Water.WaterBodyComponent.OnWaterBodyChanged
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                               bShapeOrPositionChanged                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                               bWeightmapSettingsChanged                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UWaterBodyComponent::OnWaterBodyChanged(bool bShapeOrPositionChanged, bool bWeightmapSettingsChanged)
{
	static class UFunction* Func = nullptr;

	if (!Func)
		Func = Class->GetFunction("WaterBodyComponent", "OnWaterBodyChanged");

	Params::UWaterBodyComponent_OnWaterBodyChanged_Params Parms{};

	Parms.bShapeOrPositionChanged = bShapeOrPositionChanged;
	Parms.bWeightmapSettingsChanged = bWeightmapSettingsChanged;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);


	Func->FunctionFlags = Flgs;

}


// Function Water.WaterBodyComponent.GetWaterWaves
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UWaterWavesBase*             ReturnValue                                                      (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UWaterWavesBase* UWaterBodyComponent::GetWaterWaves()
{
	static class UFunction* Func = nullptr;

	if (!Func)
		Func = Class->GetFunction("WaterBodyComponent", "GetWaterWaves");

	Params::UWaterBodyComponent_GetWaterWaves_Params Parms{};


	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);


	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;

}


// Function Water.WaterBodyComponent.GetWaterVelocityAtSplineInputKey
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                              InKey                                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                              ReturnValue                                                      (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UWaterBodyComponent::GetWaterVelocityAtSplineInputKey(float InKey)
{
	static class UFunction* Func = nullptr;

	if (!Func)
		Func = Class->GetFunction("WaterBodyComponent", "GetWaterVelocityAtSplineInputKey");

	Params::UWaterBodyComponent_GetWaterVelocityAtSplineInputKey_Params Parms{};

	Parms.InKey = InKey;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);


	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;

}


// Function Water.WaterBodyComponent.GetWaterSurfaceInfoAtLocation
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FVector                     InLocation                                                       (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector                     OutWaterSurfaceLocation                                          (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector                     OutWaterSurfaceNormal                                            (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector                     OutWaterVelocity                                                 (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                              OutWaterDepth                                                    (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                               bIncludeDepth                                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UWaterBodyComponent::GetWaterSurfaceInfoAtLocation(struct FVector& InLocation, struct FVector* OutWaterSurfaceLocation, struct FVector* OutWaterSurfaceNormal, struct FVector* OutWaterVelocity, float* OutWaterDepth, bool bIncludeDepth)
{
	static class UFunction* Func = nullptr;

	if (!Func)
		Func = Class->GetFunction("WaterBodyComponent", "GetWaterSurfaceInfoAtLocation");

	Params::UWaterBodyComponent_GetWaterSurfaceInfoAtLocation_Params Parms{};

	Parms.InLocation = InLocation;
	Parms.bIncludeDepth = bIncludeDepth;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);


	Func->FunctionFlags = Flgs;

	if (OutWaterSurfaceLocation != nullptr)
		*OutWaterSurfaceLocation = std::move(Parms.OutWaterSurfaceLocation);

	if (OutWaterSurfaceNormal != nullptr)
		*OutWaterSurfaceNormal = std::move(Parms.OutWaterSurfaceNormal);

	if (OutWaterVelocity != nullptr)
		*OutWaterVelocity = std::move(Parms.OutWaterVelocity);

	if (OutWaterDepth != nullptr)
		*OutWaterDepth = Parms.OutWaterDepth;

}


// Function Water.WaterBodyComponent.GetWaterSpline
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UWaterSplineComponent*       ReturnValue                                                      (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UWaterSplineComponent* UWaterBodyComponent::GetWaterSpline()
{
	static class UFunction* Func = nullptr;

	if (!Func)
		Func = Class->GetFunction("WaterBodyComponent", "GetWaterSpline");

	Params::UWaterBodyComponent_GetWaterSpline_Params Parms{};


	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);


	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;

}


// Function Water.WaterBodyComponent.GetWaterMaterialInstance
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UMaterialInstanceDynamic*    ReturnValue                                                      (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UMaterialInstanceDynamic* UWaterBodyComponent::GetWaterMaterialInstance()
{
	static class UFunction* Func = nullptr;

	if (!Func)
		Func = Class->GetFunction("WaterBodyComponent", "GetWaterMaterialInstance");

	Params::UWaterBodyComponent_GetWaterMaterialInstance_Params Parms{};


	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);


	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;

}


// Function Water.WaterBodyComponent.GetWaterMaterial
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UMaterialInterface*          ReturnValue                                                      (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UMaterialInterface* UWaterBodyComponent::GetWaterMaterial()
{
	static class UFunction* Func = nullptr;

	if (!Func)
		Func = Class->GetFunction("WaterBodyComponent", "GetWaterMaterial");

	Params::UWaterBodyComponent_GetWaterMaterial_Params Parms{};


	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);


	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;

}


// Function Water.WaterBodyComponent.GetWaterLODMaterialInstance
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UMaterialInstanceDynamic*    ReturnValue                                                      (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UMaterialInstanceDynamic* UWaterBodyComponent::GetWaterLODMaterialInstance()
{
	static class UFunction* Func = nullptr;

	if (!Func)
		Func = Class->GetFunction("WaterBodyComponent", "GetWaterLODMaterialInstance");

	Params::UWaterBodyComponent_GetWaterLODMaterialInstance_Params Parms{};


	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);


	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;

}


// Function Water.WaterBodyComponent.GetWaterInfoMaterialInstance
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UMaterialInstanceDynamic*    ReturnValue                                                      (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UMaterialInstanceDynamic* UWaterBodyComponent::GetWaterInfoMaterialInstance()
{
	static class UFunction* Func = nullptr;

	if (!Func)
		Func = Class->GetFunction("WaterBodyComponent", "GetWaterInfoMaterialInstance");

	Params::UWaterBodyComponent_GetWaterInfoMaterialInstance_Params Parms{};


	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);


	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;

}


// Function Water.WaterBodyComponent.GetWaterBodyActor
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class AWaterBody*                  ReturnValue                                                      (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AWaterBody* UWaterBodyComponent::GetWaterBodyActor()
{
	static class UFunction* Func = nullptr;

	if (!Func)
		Func = Class->GetFunction("WaterBodyComponent", "GetWaterBodyActor");

	Params::UWaterBodyComponent_GetWaterBodyActor_Params Parms{};


	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);


	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;

}


// Function Water.WaterBodyComponent.GetUnderwaterPostProcessMaterialInstance
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UMaterialInstanceDynamic*    ReturnValue                                                      (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UMaterialInstanceDynamic* UWaterBodyComponent::GetUnderwaterPostProcessMaterialInstance()
{
	static class UFunction* Func = nullptr;

	if (!Func)
		Func = Class->GetFunction("WaterBodyComponent", "GetUnderwaterPostProcessMaterialInstance");

	Params::UWaterBodyComponent_GetUnderwaterPostProcessMaterialInstance_Params Parms{};


	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);


	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;

}


// Function Water.WaterBodyComponent.GetStandardRenderableComponents
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TArray<class UPrimitiveComponent*> ReturnValue                                                      (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, ContainsInstancedReference, NativeAccessSpecifierPublic)

TArray<class UPrimitiveComponent*> UWaterBodyComponent::GetStandardRenderableComponents()
{
	static class UFunction* Func = nullptr;

	if (!Func)
		Func = Class->GetFunction("WaterBodyComponent", "GetStandardRenderableComponents");

	Params::UWaterBodyComponent_GetStandardRenderableComponents_Params Parms{};


	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);


	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;

}


// Function Water.WaterBodyComponent.GetRiverToOceanTransitionMaterialInstance
// (Native, Public, BlueprintCallable)
// Parameters:
// class UMaterialInstanceDynamic*    ReturnValue                                                      (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UMaterialInstanceDynamic* UWaterBodyComponent::GetRiverToOceanTransitionMaterialInstance()
{
	static class UFunction* Func = nullptr;

	if (!Func)
		Func = Class->GetFunction("WaterBodyComponent", "GetRiverToOceanTransitionMaterialInstance");

	Params::UWaterBodyComponent_GetRiverToOceanTransitionMaterialInstance_Params Parms{};


	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);


	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;

}


// Function Water.WaterBodyComponent.GetRiverToLakeTransitionMaterialInstance
// (Native, Public, BlueprintCallable)
// Parameters:
// class UMaterialInstanceDynamic*    ReturnValue                                                      (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UMaterialInstanceDynamic* UWaterBodyComponent::GetRiverToLakeTransitionMaterialInstance()
{
	static class UFunction* Func = nullptr;

	if (!Func)
		Func = Class->GetFunction("WaterBodyComponent", "GetRiverToLakeTransitionMaterialInstance");

	Params::UWaterBodyComponent_GetRiverToLakeTransitionMaterialInstance_Params Parms{};


	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);


	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;

}


// Function Water.WaterBodyComponent.GetMaxWaveHeight
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                              ReturnValue                                                      (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UWaterBodyComponent::GetMaxWaveHeight()
{
	static class UFunction* Func = nullptr;

	if (!Func)
		Func = Class->GetFunction("WaterBodyComponent", "GetMaxWaveHeight");

	Params::UWaterBodyComponent_GetMaxWaveHeight_Params Parms{};


	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);


	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;

}


// Function Water.WaterBodyComponent.GetIslands
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TArray<class AWaterBodyIsland*>    ReturnValue                                                      (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<class AWaterBodyIsland*> UWaterBodyComponent::GetIslands()
{
	static class UFunction* Func = nullptr;

	if (!Func)
		Func = Class->GetFunction("WaterBodyComponent", "GetIslands");

	Params::UWaterBodyComponent_GetIslands_Params Parms{};


	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);


	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;

}


// Function Water.WaterBodyComponent.GetExclusionVolumes
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TArray<class AWaterBodyExclusionVolume*>ReturnValue                                                      (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<class AWaterBodyExclusionVolume*> UWaterBodyComponent::GetExclusionVolumes()
{
	static class UFunction* Func = nullptr;

	if (!Func)
		Func = Class->GetFunction("WaterBodyComponent", "GetExclusionVolumes");

	Params::UWaterBodyComponent_GetExclusionVolumes_Params Parms{};


	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);


	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;

}


// Function Water.WaterBodyComponent.GetCollisionComponents
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                               bInOnlyEnabledComponents                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<class UPrimitiveComponent*> ReturnValue                                                      (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, ContainsInstancedReference, NativeAccessSpecifierPublic)

TArray<class UPrimitiveComponent*> UWaterBodyComponent::GetCollisionComponents(bool bInOnlyEnabledComponents)
{
	static class UFunction* Func = nullptr;

	if (!Func)
		Func = Class->GetFunction("WaterBodyComponent", "GetCollisionComponents");

	Params::UWaterBodyComponent_GetCollisionComponents_Params Parms{};

	Parms.bInOnlyEnabledComponents = bInOnlyEnabledComponents;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);


	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;

}


// Class Water.CustomMeshGenerator
// (None)

class UClass* UCustomMeshGenerator::StaticClass()
{
	static class UClass* Clss = nullptr;

	if (!Clss)
		Clss = UObject::FindClassFast("CustomMeshGenerator");

	return Clss;
}


// CustomMeshGenerator Water.Default__CustomMeshGenerator
// (Public, ClassDefaultObject, ArchetypeObject)

class UCustomMeshGenerator* UCustomMeshGenerator::GetDefaultObj()
{
	static class UCustomMeshGenerator* Default = nullptr;

	if (!Default)
		Default = static_cast<UCustomMeshGenerator*>(UCustomMeshGenerator::StaticClass()->DefaultObject);

	return Default;
}


// Class Water.WaterBodyCustom
// (Actor)

class UClass* AWaterBodyCustom::StaticClass()
{
	static class UClass* Clss = nullptr;

	if (!Clss)
		Clss = UObject::FindClassFast("WaterBodyCustom");

	return Clss;
}


// WaterBodyCustom Water.Default__WaterBodyCustom
// (Public, ClassDefaultObject, ArchetypeObject)

class AWaterBodyCustom* AWaterBodyCustom::GetDefaultObj()
{
	static class AWaterBodyCustom* Default = nullptr;

	if (!Default)
		Default = static_cast<AWaterBodyCustom*>(AWaterBodyCustom::StaticClass()->DefaultObject);

	return Default;
}


// Class Water.WaterBodyCustomComponent
// (SceneComponent, PrimitiveComponent)

class UClass* UWaterBodyCustomComponent::StaticClass()
{
	static class UClass* Clss = nullptr;

	if (!Clss)
		Clss = UObject::FindClassFast("WaterBodyCustomComponent");

	return Clss;
}


// WaterBodyCustomComponent Water.Default__WaterBodyCustomComponent
// (Public, ClassDefaultObject, ArchetypeObject)

class UWaterBodyCustomComponent* UWaterBodyCustomComponent::GetDefaultObj()
{
	static class UWaterBodyCustomComponent* Default = nullptr;

	if (!Default)
		Default = static_cast<UWaterBodyCustomComponent*>(UWaterBodyCustomComponent::StaticClass()->DefaultObject);

	return Default;
}


// Class Water.WaterBodyExclusionVolume
// (Actor)

class UClass* AWaterBodyExclusionVolume::StaticClass()
{
	static class UClass* Clss = nullptr;

	if (!Clss)
		Clss = UObject::FindClassFast("WaterBodyExclusionVolume");

	return Clss;
}


// WaterBodyExclusionVolume Water.Default__WaterBodyExclusionVolume
// (Public, ClassDefaultObject, ArchetypeObject)

class AWaterBodyExclusionVolume* AWaterBodyExclusionVolume::GetDefaultObj()
{
	static class AWaterBodyExclusionVolume* Default = nullptr;

	if (!Default)
		Default = static_cast<AWaterBodyExclusionVolume*>(AWaterBodyExclusionVolume::StaticClass()->DefaultObject);

	return Default;
}


// Class Water.WaterBodyHLODBuilder
// (None)

class UClass* UWaterBodyHLODBuilder::StaticClass()
{
	static class UClass* Clss = nullptr;

	if (!Clss)
		Clss = UObject::FindClassFast("WaterBodyHLODBuilder");

	return Clss;
}


// WaterBodyHLODBuilder Water.Default__WaterBodyHLODBuilder
// (Public, ClassDefaultObject, ArchetypeObject)

class UWaterBodyHLODBuilder* UWaterBodyHLODBuilder::GetDefaultObj()
{
	static class UWaterBodyHLODBuilder* Default = nullptr;

	if (!Default)
		Default = static_cast<UWaterBodyHLODBuilder*>(UWaterBodyHLODBuilder::StaticClass()->DefaultObject);

	return Default;
}


// Class Water.WaterBodyIsland
// (Actor)

class UClass* AWaterBodyIsland::StaticClass()
{
	static class UClass* Clss = nullptr;

	if (!Clss)
		Clss = UObject::FindClassFast("WaterBodyIsland");

	return Clss;
}


// WaterBodyIsland Water.Default__WaterBodyIsland
// (Public, ClassDefaultObject, ArchetypeObject)

class AWaterBodyIsland* AWaterBodyIsland::GetDefaultObj()
{
	static class AWaterBodyIsland* Default = nullptr;

	if (!Default)
		Default = static_cast<AWaterBodyIsland*>(AWaterBodyIsland::StaticClass()->DefaultObject);

	return Default;
}


// Function Water.WaterBodyIsland.GetWaterSpline
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UWaterSplineComponent*       ReturnValue                                                      (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UWaterSplineComponent* AWaterBodyIsland::GetWaterSpline()
{
	static class UFunction* Func = nullptr;

	if (!Func)
		Func = Class->GetFunction("WaterBodyIsland", "GetWaterSpline");

	Params::AWaterBodyIsland_GetWaterSpline_Params Parms{};


	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);


	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;

}


// Class Water.LakeGenerator
// (None)

class UClass* ULakeGenerator::StaticClass()
{
	static class UClass* Clss = nullptr;

	if (!Clss)
		Clss = UObject::FindClassFast("LakeGenerator");

	return Clss;
}


// LakeGenerator Water.Default__LakeGenerator
// (Public, ClassDefaultObject, ArchetypeObject)

class ULakeGenerator* ULakeGenerator::GetDefaultObj()
{
	static class ULakeGenerator* Default = nullptr;

	if (!Default)
		Default = static_cast<ULakeGenerator*>(ULakeGenerator::StaticClass()->DefaultObject);

	return Default;
}


// Class Water.WaterBodyLake
// (Actor)

class UClass* AWaterBodyLake::StaticClass()
{
	static class UClass* Clss = nullptr;

	if (!Clss)
		Clss = UObject::FindClassFast("WaterBodyLake");

	return Clss;
}


// WaterBodyLake Water.Default__WaterBodyLake
// (Public, ClassDefaultObject, ArchetypeObject)

class AWaterBodyLake* AWaterBodyLake::GetDefaultObj()
{
	static class AWaterBodyLake* Default = nullptr;

	if (!Default)
		Default = static_cast<AWaterBodyLake*>(AWaterBodyLake::StaticClass()->DefaultObject);

	return Default;
}


// Class Water.WaterBodyLakeComponent
// (SceneComponent, PrimitiveComponent)

class UClass* UWaterBodyLakeComponent::StaticClass()
{
	static class UClass* Clss = nullptr;

	if (!Clss)
		Clss = UObject::FindClassFast("WaterBodyLakeComponent");

	return Clss;
}


// WaterBodyLakeComponent Water.Default__WaterBodyLakeComponent
// (Public, ClassDefaultObject, ArchetypeObject)

class UWaterBodyLakeComponent* UWaterBodyLakeComponent::GetDefaultObj()
{
	static class UWaterBodyLakeComponent* Default = nullptr;

	if (!Default)
		Default = static_cast<UWaterBodyLakeComponent*>(UWaterBodyLakeComponent::StaticClass()->DefaultObject);

	return Default;
}


// Class Water.OceanGenerator
// (None)

class UClass* UOceanGenerator::StaticClass()
{
	static class UClass* Clss = nullptr;

	if (!Clss)
		Clss = UObject::FindClassFast("OceanGenerator");

	return Clss;
}


// OceanGenerator Water.Default__OceanGenerator
// (Public, ClassDefaultObject, ArchetypeObject)

class UOceanGenerator* UOceanGenerator::GetDefaultObj()
{
	static class UOceanGenerator* Default = nullptr;

	if (!Default)
		Default = static_cast<UOceanGenerator*>(UOceanGenerator::StaticClass()->DefaultObject);

	return Default;
}


// Class Water.WaterBodyOcean
// (Actor)

class UClass* AWaterBodyOcean::StaticClass()
{
	static class UClass* Clss = nullptr;

	if (!Clss)
		Clss = UObject::FindClassFast("WaterBodyOcean");

	return Clss;
}


// WaterBodyOcean Water.Default__WaterBodyOcean
// (Public, ClassDefaultObject, ArchetypeObject)

class AWaterBodyOcean* AWaterBodyOcean::GetDefaultObj()
{
	static class AWaterBodyOcean* Default = nullptr;

	if (!Default)
		Default = static_cast<AWaterBodyOcean*>(AWaterBodyOcean::StaticClass()->DefaultObject);

	return Default;
}


// Class Water.WaterBodyOceanComponent
// (SceneComponent, PrimitiveComponent)

class UClass* UWaterBodyOceanComponent::StaticClass()
{
	static class UClass* Clss = nullptr;

	if (!Clss)
		Clss = UObject::FindClassFast("WaterBodyOceanComponent");

	return Clss;
}


// WaterBodyOceanComponent Water.Default__WaterBodyOceanComponent
// (Public, ClassDefaultObject, ArchetypeObject)

class UWaterBodyOceanComponent* UWaterBodyOceanComponent::GetDefaultObj()
{
	static class UWaterBodyOceanComponent* Default = nullptr;

	if (!Default)
		Default = static_cast<UWaterBodyOceanComponent*>(UWaterBodyOceanComponent::StaticClass()->DefaultObject);

	return Default;
}


// Class Water.RiverGenerator
// (None)

class UClass* URiverGenerator::StaticClass()
{
	static class UClass* Clss = nullptr;

	if (!Clss)
		Clss = UObject::FindClassFast("RiverGenerator");

	return Clss;
}


// RiverGenerator Water.Default__RiverGenerator
// (Public, ClassDefaultObject, ArchetypeObject)

class URiverGenerator* URiverGenerator::GetDefaultObj()
{
	static class URiverGenerator* Default = nullptr;

	if (!Default)
		Default = static_cast<URiverGenerator*>(URiverGenerator::StaticClass()->DefaultObject);

	return Default;
}


// Class Water.WaterBodyRiver
// (Actor)

class UClass* AWaterBodyRiver::StaticClass()
{
	static class UClass* Clss = nullptr;

	if (!Clss)
		Clss = UObject::FindClassFast("WaterBodyRiver");

	return Clss;
}


// WaterBodyRiver Water.Default__WaterBodyRiver
// (Public, ClassDefaultObject, ArchetypeObject)

class AWaterBodyRiver* AWaterBodyRiver::GetDefaultObj()
{
	static class AWaterBodyRiver* Default = nullptr;

	if (!Default)
		Default = static_cast<AWaterBodyRiver*>(AWaterBodyRiver::StaticClass()->DefaultObject);

	return Default;
}


// Class Water.WaterBodyRiverComponent
// (SceneComponent, PrimitiveComponent)

class UClass* UWaterBodyRiverComponent::StaticClass()
{
	static class UClass* Clss = nullptr;

	if (!Clss)
		Clss = UObject::FindClassFast("WaterBodyRiverComponent");

	return Clss;
}


// WaterBodyRiverComponent Water.Default__WaterBodyRiverComponent
// (Public, ClassDefaultObject, ArchetypeObject)

class UWaterBodyRiverComponent* UWaterBodyRiverComponent::GetDefaultObj()
{
	static class UWaterBodyRiverComponent* Default = nullptr;

	if (!Default)
		Default = static_cast<UWaterBodyRiverComponent*>(UWaterBodyRiverComponent::StaticClass()->DefaultObject);

	return Default;
}


// Class Water.WaterBrushActorInterface
// (None)

class UClass* IWaterBrushActorInterface::StaticClass()
{
	static class UClass* Clss = nullptr;

	if (!Clss)
		Clss = UObject::FindClassFast("WaterBrushActorInterface");

	return Clss;
}


// WaterBrushActorInterface Water.Default__WaterBrushActorInterface
// (Public, ClassDefaultObject, ArchetypeObject)

class IWaterBrushActorInterface* IWaterBrushActorInterface::GetDefaultObj()
{
	static class IWaterBrushActorInterface* Default = nullptr;

	if (!Default)
		Default = static_cast<IWaterBrushActorInterface*>(IWaterBrushActorInterface::StaticClass()->DefaultObject);

	return Default;
}


// Class Water.WaterMeshComponent
// (SceneComponent, PrimitiveComponent)

class UClass* UWaterMeshComponent::StaticClass()
{
	static class UClass* Clss = nullptr;

	if (!Clss)
		Clss = UObject::FindClassFast("WaterMeshComponent");

	return Clss;
}


// WaterMeshComponent Water.Default__WaterMeshComponent
// (Public, ClassDefaultObject, ArchetypeObject)

class UWaterMeshComponent* UWaterMeshComponent::GetDefaultObj()
{
	static class UWaterMeshComponent* Default = nullptr;

	if (!Default)
		Default = static_cast<UWaterMeshComponent*>(UWaterMeshComponent::StaticClass()->DefaultObject);

	return Default;
}


// Function Water.WaterMeshComponent.IsEnabled
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                               ReturnValue                                                      (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UWaterMeshComponent::IsEnabled()
{
	static class UFunction* Func = nullptr;

	if (!Func)
		Func = Class->GetFunction("WaterMeshComponent", "IsEnabled");

	Params::UWaterMeshComponent_IsEnabled_Params Parms{};


	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);


	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;

}


// Class Water.WaterRuntimeSettings
// (None)

class UClass* UWaterRuntimeSettings::StaticClass()
{
	static class UClass* Clss = nullptr;

	if (!Clss)
		Clss = UObject::FindClassFast("WaterRuntimeSettings");

	return Clss;
}


// WaterRuntimeSettings Water.Default__WaterRuntimeSettings
// (Public, ClassDefaultObject, ArchetypeObject)

class UWaterRuntimeSettings* UWaterRuntimeSettings::GetDefaultObj()
{
	static class UWaterRuntimeSettings* Default = nullptr;

	if (!Default)
		Default = static_cast<UWaterRuntimeSettings*>(UWaterRuntimeSettings::StaticClass()->DefaultObject);

	return Default;
}


// Class Water.WaterSplineComponent
// (SceneComponent, PrimitiveComponent)

class UClass* UWaterSplineComponent::StaticClass()
{
	static class UClass* Clss = nullptr;

	if (!Clss)
		Clss = UObject::FindClassFast("WaterSplineComponent");

	return Clss;
}


// WaterSplineComponent Water.Default__WaterSplineComponent
// (Public, ClassDefaultObject, ArchetypeObject)

class UWaterSplineComponent* UWaterSplineComponent::GetDefaultObj()
{
	static class UWaterSplineComponent* Default = nullptr;

	if (!Default)
		Default = static_cast<UWaterSplineComponent*>(UWaterSplineComponent::StaticClass()->DefaultObject);

	return Default;
}


// Class Water.WaterSplineMetadata
// (None)

class UClass* UWaterSplineMetadata::StaticClass()
{
	static class UClass* Clss = nullptr;

	if (!Clss)
		Clss = UObject::FindClassFast("WaterSplineMetadata");

	return Clss;
}


// WaterSplineMetadata Water.Default__WaterSplineMetadata
// (Public, ClassDefaultObject, ArchetypeObject)

class UWaterSplineMetadata* UWaterSplineMetadata::GetDefaultObj()
{
	static class UWaterSplineMetadata* Default = nullptr;

	if (!Default)
		Default = static_cast<UWaterSplineMetadata*>(UWaterSplineMetadata::StaticClass()->DefaultObject);

	return Default;
}


// Class Water.WaterSubsystem
// (None)

class UClass* UWaterSubsystem::StaticClass()
{
	static class UClass* Clss = nullptr;

	if (!Clss)
		Clss = UObject::FindClassFast("WaterSubsystem");

	return Clss;
}


// WaterSubsystem Water.Default__WaterSubsystem
// (Public, ClassDefaultObject, ArchetypeObject)

class UWaterSubsystem* UWaterSubsystem::GetDefaultObj()
{
	static class UWaterSubsystem* Default = nullptr;

	if (!Default)
		Default = static_cast<UWaterSubsystem*>(UWaterSubsystem::StaticClass()->DefaultObject);

	return Default;
}


// Function Water.WaterSubsystem.SetOceanFloodHeight
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                              InFloodHeight                                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UWaterSubsystem::SetOceanFloodHeight(float InFloodHeight)
{
	static class UFunction* Func = nullptr;

	if (!Func)
		Func = Class->GetFunction("WaterSubsystem", "SetOceanFloodHeight");

	Params::UWaterSubsystem_SetOceanFloodHeight_Params Parms{};

	Parms.InFloodHeight = InFloodHeight;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);


	Func->FunctionFlags = Flgs;

}


// Function Water.WaterSubsystem.PrintToWaterLog
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class FString                      Message                                                          (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                               bWarning                                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UWaterSubsystem::PrintToWaterLog(const class FString& Message, bool bWarning)
{
	static class UFunction* Func = nullptr;

	if (!Func)
		Func = Class->GetFunction("WaterSubsystem", "PrintToWaterLog");

	Params::UWaterSubsystem_PrintToWaterLog_Params Parms{};

	Parms.Message = Message;
	Parms.bWarning = bWarning;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);


	Func->FunctionFlags = Flgs;

}


// Function Water.WaterSubsystem.IsWaterRenderingEnabled
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                               ReturnValue                                                      (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UWaterSubsystem::IsWaterRenderingEnabled()
{
	static class UFunction* Func = nullptr;

	if (!Func)
		Func = Class->GetFunction("WaterSubsystem", "IsWaterRenderingEnabled");

	Params::UWaterSubsystem_IsWaterRenderingEnabled_Params Parms{};


	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);


	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;

}


// Function Water.WaterSubsystem.IsUnderwaterPostProcessEnabled
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                               ReturnValue                                                      (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UWaterSubsystem::IsUnderwaterPostProcessEnabled()
{
	static class UFunction* Func = nullptr;

	if (!Func)
		Func = Class->GetFunction("WaterSubsystem", "IsUnderwaterPostProcessEnabled");

	Params::UWaterSubsystem_IsUnderwaterPostProcessEnabled_Params Parms{};


	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);


	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;

}


// Function Water.WaterSubsystem.IsShallowWaterSimulationEnabled
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                               ReturnValue                                                      (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UWaterSubsystem::IsShallowWaterSimulationEnabled()
{
	static class UFunction* Func = nullptr;

	if (!Func)
		Func = Class->GetFunction("WaterSubsystem", "IsShallowWaterSimulationEnabled");

	Params::UWaterSubsystem_IsShallowWaterSimulationEnabled_Params Parms{};


	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);


	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;

}


// Function Water.WaterSubsystem.GetWaterTimeSeconds
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                              ReturnValue                                                      (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UWaterSubsystem::GetWaterTimeSeconds()
{
	static class UFunction* Func = nullptr;

	if (!Func)
		Func = Class->GetFunction("WaterSubsystem", "GetWaterTimeSeconds");

	Params::UWaterSubsystem_GetWaterTimeSeconds_Params Parms{};


	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);


	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;

}


// Function Water.WaterSubsystem.GetSmoothedWorldTimeSeconds
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                              ReturnValue                                                      (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UWaterSubsystem::GetSmoothedWorldTimeSeconds()
{
	static class UFunction* Func = nullptr;

	if (!Func)
		Func = Class->GetFunction("WaterSubsystem", "GetSmoothedWorldTimeSeconds");

	Params::UWaterSubsystem_GetSmoothedWorldTimeSeconds_Params Parms{};


	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);


	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;

}


// Function Water.WaterSubsystem.GetShallowWaterSimulationRenderTargetSize
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// int32                              ReturnValue                                                      (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UWaterSubsystem::GetShallowWaterSimulationRenderTargetSize()
{
	static class UFunction* Func = nullptr;

	if (!Func)
		Func = Class->GetFunction("WaterSubsystem", "GetShallowWaterSimulationRenderTargetSize");

	Params::UWaterSubsystem_GetShallowWaterSimulationRenderTargetSize_Params Parms{};


	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);


	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;

}


// Function Water.WaterSubsystem.GetShallowWaterMaxImpulseForces
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// int32                              ReturnValue                                                      (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UWaterSubsystem::GetShallowWaterMaxImpulseForces()
{
	static class UFunction* Func = nullptr;

	if (!Func)
		Func = Class->GetFunction("WaterSubsystem", "GetShallowWaterMaxImpulseForces");

	Params::UWaterSubsystem_GetShallowWaterMaxImpulseForces_Params Parms{};


	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);


	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;

}


// Function Water.WaterSubsystem.GetShallowWaterMaxDynamicForces
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// int32                              ReturnValue                                                      (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UWaterSubsystem::GetShallowWaterMaxDynamicForces()
{
	static class UFunction* Func = nullptr;

	if (!Func)
		Func = Class->GetFunction("WaterSubsystem", "GetShallowWaterMaxDynamicForces");

	Params::UWaterSubsystem_GetShallowWaterMaxDynamicForces_Params Parms{};


	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);


	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;

}


// Function Water.WaterSubsystem.GetOceanTotalHeight
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                              ReturnValue                                                      (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UWaterSubsystem::GetOceanTotalHeight()
{
	static class UFunction* Func = nullptr;

	if (!Func)
		Func = Class->GetFunction("WaterSubsystem", "GetOceanTotalHeight");

	Params::UWaterSubsystem_GetOceanTotalHeight_Params Parms{};


	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);


	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;

}


// Function Water.WaterSubsystem.GetOceanFloodHeight
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                              ReturnValue                                                      (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UWaterSubsystem::GetOceanFloodHeight()
{
	static class UFunction* Func = nullptr;

	if (!Func)
		Func = Class->GetFunction("WaterSubsystem", "GetOceanFloodHeight");

	Params::UWaterSubsystem_GetOceanFloodHeight_Params Parms{};


	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);


	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;

}


// Function Water.WaterSubsystem.GetOceanBaseHeight
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                              ReturnValue                                                      (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UWaterSubsystem::GetOceanBaseHeight()
{
	static class UFunction* Func = nullptr;

	if (!Func)
		Func = Class->GetFunction("WaterSubsystem", "GetOceanBaseHeight");

	Params::UWaterSubsystem_GetOceanBaseHeight_Params Parms{};


	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);


	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;

}


// Function Water.WaterSubsystem.GetCameraUnderwaterDepth
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                              ReturnValue                                                      (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UWaterSubsystem::GetCameraUnderwaterDepth()
{
	static class UFunction* Func = nullptr;

	if (!Func)
		Func = Class->GetFunction("WaterSubsystem", "GetCameraUnderwaterDepth");

	Params::UWaterSubsystem_GetCameraUnderwaterDepth_Params Parms{};


	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);


	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;

}


// Class Water.WaterWavesAsset
// (None)

class UClass* UWaterWavesAsset::StaticClass()
{
	static class UClass* Clss = nullptr;

	if (!Clss)
		Clss = UObject::FindClassFast("WaterWavesAsset");

	return Clss;
}


// WaterWavesAsset Water.Default__WaterWavesAsset
// (Public, ClassDefaultObject, ArchetypeObject)

class UWaterWavesAsset* UWaterWavesAsset::GetDefaultObj()
{
	static class UWaterWavesAsset* Default = nullptr;

	if (!Default)
		Default = static_cast<UWaterWavesAsset*>(UWaterWavesAsset::StaticClass()->DefaultObject);

	return Default;
}


// Class Water.WaterWavesAssetReference
// (None)

class UClass* UWaterWavesAssetReference::StaticClass()
{
	static class UClass* Clss = nullptr;

	if (!Clss)
		Clss = UObject::FindClassFast("WaterWavesAssetReference");

	return Clss;
}


// WaterWavesAssetReference Water.Default__WaterWavesAssetReference
// (Public, ClassDefaultObject, ArchetypeObject)

class UWaterWavesAssetReference* UWaterWavesAssetReference::GetDefaultObj()
{
	static class UWaterWavesAssetReference* Default = nullptr;

	if (!Default)
		Default = static_cast<UWaterWavesAssetReference*>(UWaterWavesAssetReference::StaticClass()->DefaultObject);

	return Default;
}


// Class Water.WaterZone
// (Actor)

class UClass* AWaterZone::StaticClass()
{
	static class UClass* Clss = nullptr;

	if (!Clss)
		Clss = UObject::FindClassFast("WaterZone");

	return Clss;
}


// WaterZone Water.Default__WaterZone
// (Public, ClassDefaultObject, ArchetypeObject)

class AWaterZone* AWaterZone::GetDefaultObj()
{
	static class AWaterZone* Default = nullptr;

	if (!Default)
		Default = static_cast<AWaterZone*>(AWaterZone::StaticClass()->DefaultObject);

	return Default;
}

}