第一次上传

This commit is contained in:
gcdsfh145
2026-05-02 14:30:03 +08:00
parent e608ad8612
commit 8bff0040f2
3231 changed files with 652400 additions and 1 deletions
+580
View File
@@ -0,0 +1,580 @@
//PUBGM(0.13.5)32位SDK
//作者:清华
//Telegram:@qinghuanb666
//生成时间:Fri Apr 18 20:44:40 2025
#include "../SDK.hpp"
namespace SDK
{
//---------------------------------------------------------------------------
//Functions
//---------------------------------------------------------------------------
// Function ProceduralMeshComponent.KismetProceduralMeshLibrary.SliceProceduralMesh
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable)
// Parameters:
// class UProceduralMeshComponent* InProcMesh (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
// struct FVector PlanePosition (Parm, IsPlainOldData)
// struct FVector PlaneNormal (Parm, IsPlainOldData)
// bool bCreateOtherHalf (Parm, ZeroConstructor, IsPlainOldData)
// class UProceduralMeshComponent* OutOtherHalfProcMesh (Parm, OutParm, ZeroConstructor, InstancedReference, IsPlainOldData)
// EProcMeshSliceCapOption CapOption (Parm, ZeroConstructor, IsPlainOldData)
// class UMaterialInterface* CapMaterial (Parm, ZeroConstructor, IsPlainOldData)
void UKismetProceduralMeshLibrary::SliceProceduralMesh(class UProceduralMeshComponent* InProcMesh, const struct FVector& PlanePosition, const struct FVector& PlaneNormal, bool bCreateOtherHalf, class UMaterialInterface* CapMaterial, EProcMeshSliceCapOption CapOption, class UProceduralMeshComponent** OutOtherHalfProcMesh)
{
static UFunction *pFunc = 0;
if (!pFunc)
pFunc = UObject::FindObject<UFunction>("Function ProceduralMeshComponent.KismetProceduralMeshLibrary.SliceProceduralMesh");
UKismetProceduralMeshLibrary_SliceProceduralMesh_Params params;
params.InProcMesh = InProcMesh;
params.PlanePosition = PlanePosition;
params.PlaneNormal = PlaneNormal;
params.bCreateOtherHalf = bCreateOtherHalf;
params.CapOption = CapOption;
params.CapMaterial = CapMaterial;
auto flags = pFunc->FunctionFlags;
pFunc->FunctionFlags |= 0x400;
static auto defaultObj = StaticClass()->GetDefaultObject();
defaultObj->ProcessEvent(pFunc, &params);
pFunc->FunctionFlags = flags;
if (OutOtherHalfProcMesh != nullptr)
*OutOtherHalfProcMesh = params.OutOtherHalfProcMesh;
}
// Function ProceduralMeshComponent.KismetProceduralMeshLibrary.GetSectionFromStaticMesh
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable)
// Parameters:
// class UStaticMesh* InMesh (Parm, ZeroConstructor, IsPlainOldData)
// int LODIndex (Parm, ZeroConstructor, IsPlainOldData)
// int SectionIndex (Parm, ZeroConstructor, IsPlainOldData)
// TArray<struct FVector> Vertices (Parm, OutParm, ZeroConstructor)
// TArray<int> Triangles (Parm, OutParm, ZeroConstructor)
// TArray<struct FVector> Normals (Parm, OutParm, ZeroConstructor)
// TArray<struct FVector2D> UVs (Parm, OutParm, ZeroConstructor)
// TArray<struct FProcMeshTangent> Tangents (Parm, OutParm, ZeroConstructor)
void UKismetProceduralMeshLibrary::GetSectionFromStaticMesh(class UStaticMesh* InMesh, int LODIndex, int SectionIndex, TArray<struct FVector>* Vertices, TArray<int>* Triangles, TArray<struct FVector>* Normals, TArray<struct FVector2D>* UVs, TArray<struct FProcMeshTangent>* Tangents)
{
static UFunction *pFunc = 0;
if (!pFunc)
pFunc = UObject::FindObject<UFunction>("Function ProceduralMeshComponent.KismetProceduralMeshLibrary.GetSectionFromStaticMesh");
UKismetProceduralMeshLibrary_GetSectionFromStaticMesh_Params params;
params.InMesh = InMesh;
params.LODIndex = LODIndex;
params.SectionIndex = SectionIndex;
auto flags = pFunc->FunctionFlags;
pFunc->FunctionFlags |= 0x400;
static auto defaultObj = StaticClass()->GetDefaultObject();
defaultObj->ProcessEvent(pFunc, &params);
pFunc->FunctionFlags = flags;
if (Vertices != nullptr)
*Vertices = params.Vertices;
if (Triangles != nullptr)
*Triangles = params.Triangles;
if (Normals != nullptr)
*Normals = params.Normals;
if (UVs != nullptr)
*UVs = params.UVs;
if (Tangents != nullptr)
*Tangents = params.Tangents;
}
// Function ProceduralMeshComponent.KismetProceduralMeshLibrary.GenerateBoxMesh
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable)
// Parameters:
// struct FVector BoxRadius (Parm, IsPlainOldData)
// TArray<struct FVector> Vertices (Parm, OutParm, ZeroConstructor)
// TArray<int> Triangles (Parm, OutParm, ZeroConstructor)
// TArray<struct FVector> Normals (Parm, OutParm, ZeroConstructor)
// TArray<struct FVector2D> UVs (Parm, OutParm, ZeroConstructor)
// TArray<struct FProcMeshTangent> Tangents (Parm, OutParm, ZeroConstructor)
void UKismetProceduralMeshLibrary::GenerateBoxMesh(const struct FVector& BoxRadius, TArray<struct FVector>* Vertices, TArray<int>* Triangles, TArray<struct FVector>* Normals, TArray<struct FVector2D>* UVs, TArray<struct FProcMeshTangent>* Tangents)
{
static UFunction *pFunc = 0;
if (!pFunc)
pFunc = UObject::FindObject<UFunction>("Function ProceduralMeshComponent.KismetProceduralMeshLibrary.GenerateBoxMesh");
UKismetProceduralMeshLibrary_GenerateBoxMesh_Params params;
params.BoxRadius = BoxRadius;
auto flags = pFunc->FunctionFlags;
pFunc->FunctionFlags |= 0x400;
static auto defaultObj = StaticClass()->GetDefaultObject();
defaultObj->ProcessEvent(pFunc, &params);
pFunc->FunctionFlags = flags;
if (Vertices != nullptr)
*Vertices = params.Vertices;
if (Triangles != nullptr)
*Triangles = params.Triangles;
if (Normals != nullptr)
*Normals = params.Normals;
if (UVs != nullptr)
*UVs = params.UVs;
if (Tangents != nullptr)
*Tangents = params.Tangents;
}
// Function ProceduralMeshComponent.KismetProceduralMeshLibrary.CreateGridMeshTriangles
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable)
// Parameters:
// int NumX (Parm, ZeroConstructor, IsPlainOldData)
// int NumY (Parm, ZeroConstructor, IsPlainOldData)
// bool bWinding (Parm, ZeroConstructor, IsPlainOldData)
// TArray<int> Triangles (Parm, OutParm, ZeroConstructor)
void UKismetProceduralMeshLibrary::CreateGridMeshTriangles(int NumX, int NumY, bool bWinding, TArray<int>* Triangles)
{
static UFunction *pFunc = 0;
if (!pFunc)
pFunc = UObject::FindObject<UFunction>("Function ProceduralMeshComponent.KismetProceduralMeshLibrary.CreateGridMeshTriangles");
UKismetProceduralMeshLibrary_CreateGridMeshTriangles_Params params;
params.NumX = NumX;
params.NumY = NumY;
params.bWinding = bWinding;
auto flags = pFunc->FunctionFlags;
pFunc->FunctionFlags |= 0x400;
static auto defaultObj = StaticClass()->GetDefaultObject();
defaultObj->ProcessEvent(pFunc, &params);
pFunc->FunctionFlags = flags;
if (Triangles != nullptr)
*Triangles = params.Triangles;
}
// Function ProceduralMeshComponent.KismetProceduralMeshLibrary.CopyProceduralMeshFromStaticMeshComponent
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UStaticMeshComponent* StaticMeshComponent (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
// int LODIndex (Parm, ZeroConstructor, IsPlainOldData)
// class UProceduralMeshComponent* ProcMeshComponent (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
// bool bCreateCollision (Parm, ZeroConstructor, IsPlainOldData)
void UKismetProceduralMeshLibrary::CopyProceduralMeshFromStaticMeshComponent(class UStaticMeshComponent* StaticMeshComponent, int LODIndex, class UProceduralMeshComponent* ProcMeshComponent, bool bCreateCollision)
{
static UFunction *pFunc = 0;
if (!pFunc)
pFunc = UObject::FindObject<UFunction>("Function ProceduralMeshComponent.KismetProceduralMeshLibrary.CopyProceduralMeshFromStaticMeshComponent");
UKismetProceduralMeshLibrary_CopyProceduralMeshFromStaticMeshComponent_Params params;
params.StaticMeshComponent = StaticMeshComponent;
params.LODIndex = LODIndex;
params.ProcMeshComponent = ProcMeshComponent;
params.bCreateCollision = bCreateCollision;
auto flags = pFunc->FunctionFlags;
pFunc->FunctionFlags |= 0x400;
static auto defaultObj = StaticClass()->GetDefaultObject();
defaultObj->ProcessEvent(pFunc, &params);
pFunc->FunctionFlags = flags;
}
// Function ProceduralMeshComponent.KismetProceduralMeshLibrary.ConvertQuadToTriangles
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable)
// Parameters:
// TArray<int> Triangles (Parm, OutParm, ZeroConstructor, ReferenceParm)
// int Vert0 (Parm, ZeroConstructor, IsPlainOldData)
// int Vert1 (Parm, ZeroConstructor, IsPlainOldData)
// int Vert2 (Parm, ZeroConstructor, IsPlainOldData)
// int Vert3 (Parm, ZeroConstructor, IsPlainOldData)
void UKismetProceduralMeshLibrary::ConvertQuadToTriangles(int Vert0, int Vert1, int Vert2, int Vert3, TArray<int>* Triangles)
{
static UFunction *pFunc = 0;
if (!pFunc)
pFunc = UObject::FindObject<UFunction>("Function ProceduralMeshComponent.KismetProceduralMeshLibrary.ConvertQuadToTriangles");
UKismetProceduralMeshLibrary_ConvertQuadToTriangles_Params params;
params.Vert0 = Vert0;
params.Vert1 = Vert1;
params.Vert2 = Vert2;
params.Vert3 = Vert3;
auto flags = pFunc->FunctionFlags;
pFunc->FunctionFlags |= 0x400;
static auto defaultObj = StaticClass()->GetDefaultObject();
defaultObj->ProcessEvent(pFunc, &params);
pFunc->FunctionFlags = flags;
if (Triangles != nullptr)
*Triangles = params.Triangles;
}
// Function ProceduralMeshComponent.KismetProceduralMeshLibrary.CalculateTangentsForMesh
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable)
// Parameters:
// TArray<struct FVector> Vertices (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
// TArray<int> Triangles (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
// TArray<struct FVector2D> UVs (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
// TArray<struct FVector> Normals (Parm, OutParm, ZeroConstructor)
// TArray<struct FProcMeshTangent> Tangents (Parm, OutParm, ZeroConstructor)
void UKismetProceduralMeshLibrary::CalculateTangentsForMesh(TArray<struct FVector> Vertices, TArray<int> Triangles, TArray<struct FVector2D> UVs, TArray<struct FVector>* Normals, TArray<struct FProcMeshTangent>* Tangents)
{
static UFunction *pFunc = 0;
if (!pFunc)
pFunc = UObject::FindObject<UFunction>("Function ProceduralMeshComponent.KismetProceduralMeshLibrary.CalculateTangentsForMesh");
UKismetProceduralMeshLibrary_CalculateTangentsForMesh_Params params;
params.Vertices = Vertices;
params.Triangles = Triangles;
params.UVs = UVs;
auto flags = pFunc->FunctionFlags;
pFunc->FunctionFlags |= 0x400;
static auto defaultObj = StaticClass()->GetDefaultObject();
defaultObj->ProcessEvent(pFunc, &params);
pFunc->FunctionFlags = flags;
if (Normals != nullptr)
*Normals = params.Normals;
if (Tangents != nullptr)
*Tangents = params.Tangents;
}
// Function ProceduralMeshComponent.ProceduralMeshComponent.UpdateMeshSection_LinearColor
// (Final, Native, Public, HasOutParms, BlueprintCallable)
// Parameters:
// int SectionIndex (Parm, ZeroConstructor, IsPlainOldData)
// TArray<struct FVector> Vertices (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
// TArray<struct FVector> Normals (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
// TArray<struct FVector2D> UV0 (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
// TArray<struct FLinearColor> VertexColors (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
// TArray<struct FProcMeshTangent> Tangents (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
void UProceduralMeshComponent::UpdateMeshSection_LinearColor(int SectionIndex, TArray<struct FVector> Vertices, TArray<struct FVector> Normals, TArray<struct FVector2D> UV0, TArray<struct FLinearColor> VertexColors, TArray<struct FProcMeshTangent> Tangents)
{
static UFunction *pFunc = 0;
if (!pFunc)
pFunc = UObject::FindObject<UFunction>("Function ProceduralMeshComponent.ProceduralMeshComponent.UpdateMeshSection_LinearColor");
UProceduralMeshComponent_UpdateMeshSection_LinearColor_Params params;
params.SectionIndex = SectionIndex;
params.Vertices = Vertices;
params.Normals = Normals;
params.UV0 = UV0;
params.VertexColors = VertexColors;
params.Tangents = Tangents;
auto flags = pFunc->FunctionFlags;
pFunc->FunctionFlags |= 0x400;
UObject *currentObj = (UObject *) this;
currentObj->ProcessEvent(pFunc, &params);
pFunc->FunctionFlags = flags;
}
// Function ProceduralMeshComponent.ProceduralMeshComponent.UpdateMeshSection
// (Final, Native, Public, HasOutParms, BlueprintCallable)
// Parameters:
// int SectionIndex (Parm, ZeroConstructor, IsPlainOldData)
// TArray<struct FVector> Vertices (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
// TArray<struct FVector> Normals (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
// TArray<struct FVector2D> UV0 (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
// TArray<struct FColor> VertexColors (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
// TArray<struct FProcMeshTangent> Tangents (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
void UProceduralMeshComponent::UpdateMeshSection(int SectionIndex, TArray<struct FVector> Vertices, TArray<struct FVector> Normals, TArray<struct FVector2D> UV0, TArray<struct FColor> VertexColors, TArray<struct FProcMeshTangent> Tangents)
{
static UFunction *pFunc = 0;
if (!pFunc)
pFunc = UObject::FindObject<UFunction>("Function ProceduralMeshComponent.ProceduralMeshComponent.UpdateMeshSection");
UProceduralMeshComponent_UpdateMeshSection_Params params;
params.SectionIndex = SectionIndex;
params.Vertices = Vertices;
params.Normals = Normals;
params.UV0 = UV0;
params.VertexColors = VertexColors;
params.Tangents = Tangents;
auto flags = pFunc->FunctionFlags;
pFunc->FunctionFlags |= 0x400;
UObject *currentObj = (UObject *) this;
currentObj->ProcessEvent(pFunc, &params);
pFunc->FunctionFlags = flags;
}
// Function ProceduralMeshComponent.ProceduralMeshComponent.SetMeshSectionVisible
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int SectionIndex (Parm, ZeroConstructor, IsPlainOldData)
// bool bNewVisibility (Parm, ZeroConstructor, IsPlainOldData)
void UProceduralMeshComponent::SetMeshSectionVisible(int SectionIndex, bool bNewVisibility)
{
static UFunction *pFunc = 0;
if (!pFunc)
pFunc = UObject::FindObject<UFunction>("Function ProceduralMeshComponent.ProceduralMeshComponent.SetMeshSectionVisible");
UProceduralMeshComponent_SetMeshSectionVisible_Params params;
params.SectionIndex = SectionIndex;
params.bNewVisibility = bNewVisibility;
auto flags = pFunc->FunctionFlags;
pFunc->FunctionFlags |= 0x400;
UObject *currentObj = (UObject *) this;
currentObj->ProcessEvent(pFunc, &params);
pFunc->FunctionFlags = flags;
}
// Function ProceduralMeshComponent.ProceduralMeshComponent.IsMeshSectionVisible
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int SectionIndex (Parm, ZeroConstructor, IsPlainOldData)
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
bool UProceduralMeshComponent::IsMeshSectionVisible(int SectionIndex)
{
static UFunction *pFunc = 0;
if (!pFunc)
pFunc = UObject::FindObject<UFunction>("Function ProceduralMeshComponent.ProceduralMeshComponent.IsMeshSectionVisible");
UProceduralMeshComponent_IsMeshSectionVisible_Params params;
params.SectionIndex = SectionIndex;
auto flags = pFunc->FunctionFlags;
pFunc->FunctionFlags |= 0x400;
UObject *currentObj = (UObject *) this;
currentObj->ProcessEvent(pFunc, &params);
pFunc->FunctionFlags = flags;
return params.ReturnValue;
}
// Function ProceduralMeshComponent.ProceduralMeshComponent.GetNumSections
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
int UProceduralMeshComponent::GetNumSections()
{
static UFunction *pFunc = 0;
if (!pFunc)
pFunc = UObject::FindObject<UFunction>("Function ProceduralMeshComponent.ProceduralMeshComponent.GetNumSections");
UProceduralMeshComponent_GetNumSections_Params params;
auto flags = pFunc->FunctionFlags;
pFunc->FunctionFlags |= 0x400;
UObject *currentObj = (UObject *) this;
currentObj->ProcessEvent(pFunc, &params);
pFunc->FunctionFlags = flags;
return params.ReturnValue;
}
// Function ProceduralMeshComponent.ProceduralMeshComponent.CreateMeshSection_LinearColor
// (Final, Native, Public, HasOutParms, BlueprintCallable)
// Parameters:
// int SectionIndex (Parm, ZeroConstructor, IsPlainOldData)
// TArray<struct FVector> Vertices (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
// TArray<int> Triangles (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
// TArray<struct FVector> Normals (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
// TArray<struct FVector2D> UV0 (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
// TArray<struct FLinearColor> VertexColors (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
// TArray<struct FProcMeshTangent> Tangents (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
// bool bCreateCollision (Parm, ZeroConstructor, IsPlainOldData)
void UProceduralMeshComponent::CreateMeshSection_LinearColor(int SectionIndex, TArray<struct FVector> Vertices, TArray<int> Triangles, TArray<struct FVector> Normals, TArray<struct FVector2D> UV0, TArray<struct FLinearColor> VertexColors, TArray<struct FProcMeshTangent> Tangents, bool bCreateCollision)
{
static UFunction *pFunc = 0;
if (!pFunc)
pFunc = UObject::FindObject<UFunction>("Function ProceduralMeshComponent.ProceduralMeshComponent.CreateMeshSection_LinearColor");
UProceduralMeshComponent_CreateMeshSection_LinearColor_Params params;
params.SectionIndex = SectionIndex;
params.Vertices = Vertices;
params.Triangles = Triangles;
params.Normals = Normals;
params.UV0 = UV0;
params.VertexColors = VertexColors;
params.Tangents = Tangents;
params.bCreateCollision = bCreateCollision;
auto flags = pFunc->FunctionFlags;
pFunc->FunctionFlags |= 0x400;
UObject *currentObj = (UObject *) this;
currentObj->ProcessEvent(pFunc, &params);
pFunc->FunctionFlags = flags;
}
// Function ProceduralMeshComponent.ProceduralMeshComponent.CreateMeshSection
// (Final, Native, Public, HasOutParms, BlueprintCallable)
// Parameters:
// int SectionIndex (Parm, ZeroConstructor, IsPlainOldData)
// TArray<struct FVector> Vertices (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
// TArray<int> Triangles (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
// TArray<struct FVector> Normals (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
// TArray<struct FVector2D> UV0 (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
// TArray<struct FColor> VertexColors (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
// TArray<struct FProcMeshTangent> Tangents (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
// bool bCreateCollision (Parm, ZeroConstructor, IsPlainOldData)
void UProceduralMeshComponent::CreateMeshSection(int SectionIndex, TArray<struct FVector> Vertices, TArray<int> Triangles, TArray<struct FVector> Normals, TArray<struct FVector2D> UV0, TArray<struct FColor> VertexColors, TArray<struct FProcMeshTangent> Tangents, bool bCreateCollision)
{
static UFunction *pFunc = 0;
if (!pFunc)
pFunc = UObject::FindObject<UFunction>("Function ProceduralMeshComponent.ProceduralMeshComponent.CreateMeshSection");
UProceduralMeshComponent_CreateMeshSection_Params params;
params.SectionIndex = SectionIndex;
params.Vertices = Vertices;
params.Triangles = Triangles;
params.Normals = Normals;
params.UV0 = UV0;
params.VertexColors = VertexColors;
params.Tangents = Tangents;
params.bCreateCollision = bCreateCollision;
auto flags = pFunc->FunctionFlags;
pFunc->FunctionFlags |= 0x400;
UObject *currentObj = (UObject *) this;
currentObj->ProcessEvent(pFunc, &params);
pFunc->FunctionFlags = flags;
}
// Function ProceduralMeshComponent.ProceduralMeshComponent.ClearMeshSection
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int SectionIndex (Parm, ZeroConstructor, IsPlainOldData)
void UProceduralMeshComponent::ClearMeshSection(int SectionIndex)
{
static UFunction *pFunc = 0;
if (!pFunc)
pFunc = UObject::FindObject<UFunction>("Function ProceduralMeshComponent.ProceduralMeshComponent.ClearMeshSection");
UProceduralMeshComponent_ClearMeshSection_Params params;
params.SectionIndex = SectionIndex;
auto flags = pFunc->FunctionFlags;
pFunc->FunctionFlags |= 0x400;
UObject *currentObj = (UObject *) this;
currentObj->ProcessEvent(pFunc, &params);
pFunc->FunctionFlags = flags;
}
// Function ProceduralMeshComponent.ProceduralMeshComponent.ClearCollisionConvexMeshes
// (Final, Native, Public, BlueprintCallable)
void UProceduralMeshComponent::ClearCollisionConvexMeshes()
{
static UFunction *pFunc = 0;
if (!pFunc)
pFunc = UObject::FindObject<UFunction>("Function ProceduralMeshComponent.ProceduralMeshComponent.ClearCollisionConvexMeshes");
UProceduralMeshComponent_ClearCollisionConvexMeshes_Params params;
auto flags = pFunc->FunctionFlags;
pFunc->FunctionFlags |= 0x400;
UObject *currentObj = (UObject *) this;
currentObj->ProcessEvent(pFunc, &params);
pFunc->FunctionFlags = flags;
}
// Function ProceduralMeshComponent.ProceduralMeshComponent.ClearAllMeshSections
// (Final, Native, Public, BlueprintCallable)
void UProceduralMeshComponent::ClearAllMeshSections()
{
static UFunction *pFunc = 0;
if (!pFunc)
pFunc = UObject::FindObject<UFunction>("Function ProceduralMeshComponent.ProceduralMeshComponent.ClearAllMeshSections");
UProceduralMeshComponent_ClearAllMeshSections_Params params;
auto flags = pFunc->FunctionFlags;
pFunc->FunctionFlags |= 0x400;
UObject *currentObj = (UObject *) this;
currentObj->ProcessEvent(pFunc, &params);
pFunc->FunctionFlags = flags;
}
// Function ProceduralMeshComponent.ProceduralMeshComponent.AddCollisionConvexMesh
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// TArray<struct FVector> ConvexVerts (Parm, ZeroConstructor)
void UProceduralMeshComponent::AddCollisionConvexMesh(TArray<struct FVector> ConvexVerts)
{
static UFunction *pFunc = 0;
if (!pFunc)
pFunc = UObject::FindObject<UFunction>("Function ProceduralMeshComponent.ProceduralMeshComponent.AddCollisionConvexMesh");
UProceduralMeshComponent_AddCollisionConvexMesh_Params params;
params.ConvexVerts = ConvexVerts;
auto flags = pFunc->FunctionFlags;
pFunc->FunctionFlags |= 0x400;
UObject *currentObj = (UObject *) this;
currentObj->ProcessEvent(pFunc, &params);
pFunc->FunctionFlags = flags;
}
}