gcdsfh145
581 lines
24 KiB
C++
Executable File
581 lines
24 KiB
C++
Executable File
//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, ¶ms);
|
|
|
|
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, ¶ms);
|
|
|
|
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, ¶ms);
|
|
|
|
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, ¶ms);
|
|
|
|
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, ¶ms);
|
|
|
|
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, ¶ms);
|
|
|
|
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, ¶ms);
|
|
|
|
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, ¶ms);
|
|
|
|
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, ¶ms);
|
|
|
|
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, ¶ms);
|
|
|
|
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, ¶ms);
|
|
|
|
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, ¶ms);
|
|
|
|
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, ¶ms);
|
|
|
|
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, ¶ms);
|
|
|
|
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, ¶ms);
|
|
|
|
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, ¶ms);
|
|
|
|
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, ¶ms);
|
|
|
|
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, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
}
|
|
|