Init
This commit is contained in:
@@ -0,0 +1,52 @@
|
||||
/*
|
||||
* Tencent is pleased to support the open source community by making Puerts available.
|
||||
* Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
|
||||
* Puerts is licensed under the BSD 3-Clause License, except for the third-party components listed in the file 'LICENSE' which may
|
||||
* be subject to their corresponding license terms. This file is subject to the terms and conditions defined in file 'LICENSE',
|
||||
* which is part of this source code package.
|
||||
*/
|
||||
|
||||
// gen by puerts gen tools
|
||||
|
||||
#include "CoreMinimal.h"
|
||||
#include "UsingTypeDecl.hpp"
|
||||
|
||||
struct AutoRegisterForFBox2D
|
||||
{
|
||||
AutoRegisterForFBox2D()
|
||||
{
|
||||
puerts::DefineClass<FBox2D>()
|
||||
.Constructor(CombineConstructors(MakeConstructor(FBox2D), MakeConstructor(FBox2D, EForceInit),
|
||||
MakeConstructor(FBox2D, const FVector2D&, const FVector2D&), MakeConstructor(FBox2D, const FVector2D*, const int32),
|
||||
MakeConstructor(FBox2D, const TArray<FVector2D>&)))
|
||||
.Property("Min", MakeProperty(&FBox2D::Min))
|
||||
.Property("Max", MakeProperty(&FBox2D::Max))
|
||||
.Property("bIsValid", MakeProperty(&FBox2D::bIsValid))
|
||||
.Method("op_Equality", MakeFunction(&FBox2D::operator==))
|
||||
.Method("op_Inequality", MakeFunction(&FBox2D::operator!=))
|
||||
.Method("op_Addition", CombineOverloads(MakeOverload(FBox2D(FBox2D::*)(const FVector2D&) const, &FBox2D::operator+),
|
||||
MakeOverload(FBox2D(FBox2D::*)(const FBox2D&) const, &FBox2D::operator+)))
|
||||
.Method("set_Item", SelectFunction(FVector2D & (FBox2D::*) (int32), &FBox2D::operator[]))
|
||||
.Method("ComputeSquaredDistanceToPoint", MakeFunction(&FBox2D::ComputeSquaredDistanceToPoint))
|
||||
#if ENGINE_MAJOR_VERSION >= 5 && ENGINE_MINOR_VERSION > 2
|
||||
.Method("ExpandBy", SelectFunction(FBox2D(FBox2D::*)(const double W) const, &FBox2D::ExpandBy))
|
||||
#else
|
||||
.Method("ExpandBy", SelectFunction(FBox2D(FBox2D::*)(const float W) const, &FBox2D::ExpandBy))
|
||||
#endif
|
||||
.Method("GetArea", MakeFunction(&FBox2D::GetArea))
|
||||
.Method("GetCenter", MakeFunction(&FBox2D::GetCenter))
|
||||
.Method("GetCenterAndExtents", MakeFunction(&FBox2D::GetCenterAndExtents))
|
||||
.Method("GetClosestPointTo", MakeFunction(&FBox2D::GetClosestPointTo))
|
||||
.Method("GetExtent", MakeFunction(&FBox2D::GetExtent))
|
||||
.Method("GetSize", MakeFunction(&FBox2D::GetSize))
|
||||
.Method("Init", MakeFunction(&FBox2D::Init))
|
||||
.Method("Intersect", MakeFunction(&FBox2D::Intersect))
|
||||
.Method("IsInside", CombineOverloads(MakeOverload(bool (FBox2D::*)(const FVector2D&) const, &FBox2D::IsInside),
|
||||
MakeOverload(bool (FBox2D::*)(const FBox2D&) const, &FBox2D::IsInside)))
|
||||
.Method("ShiftBy", MakeFunction(&FBox2D::ShiftBy))
|
||||
.Method("ToString", MakeFunction(&FBox2D::ToString))
|
||||
.Register();
|
||||
}
|
||||
};
|
||||
|
||||
AutoRegisterForFBox2D _AutoRegisterForFBox2D_;
|
||||
@@ -0,0 +1,57 @@
|
||||
/*
|
||||
* Tencent is pleased to support the open source community by making Puerts available.
|
||||
* Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
|
||||
* Puerts is licensed under the BSD 3-Clause License, except for the third-party components listed in the file 'LICENSE' which may
|
||||
* be subject to their corresponding license terms. This file is subject to the terms and conditions defined in file 'LICENSE',
|
||||
* which is part of this source code package.
|
||||
*/
|
||||
|
||||
// gen by puerts gen tools
|
||||
|
||||
#include "CoreMinimal.h"
|
||||
#include "UsingTypeDecl.hpp"
|
||||
|
||||
struct AutoRegisterForFColor
|
||||
{
|
||||
AutoRegisterForFColor()
|
||||
{
|
||||
puerts::DefineClass<FColor>()
|
||||
.Constructor(CombineConstructors(MakeConstructor(FColor), MakeConstructor(FColor, EForceInit),
|
||||
MakeConstructor(FColor, uint8, uint8, uint8, uint8), MakeConstructor(FColor, uint32)))
|
||||
.Method("DWColor", CombineOverloads(MakeOverload(uint32 & (FColor::*) (), &FColor::DWColor),
|
||||
MakeOverload(const uint32& (FColor::*) () const, &FColor::DWColor)))
|
||||
.Method("op_Equality", MakeFunction(&FColor::operator==))
|
||||
.Method("op_Inequality", MakeFunction(&FColor::operator!=))
|
||||
.Method("FromRGBE", MakeFunction(&FColor::FromRGBE))
|
||||
.Function("FromHex", MakeFunction(&FColor::FromHex))
|
||||
.Function("MakeRandomColor", MakeFunction(&FColor::MakeRandomColor))
|
||||
.Function("MakeRedToGreenColorFromScalar", MakeFunction(&FColor::MakeRedToGreenColorFromScalar))
|
||||
.Function("MakeFromColorTemperature", MakeFunction(&FColor::MakeFromColorTemperature))
|
||||
.Method("WithAlpha", MakeFunction(&FColor::WithAlpha))
|
||||
.Method("ReinterpretAsLinear", MakeFunction(&FColor::ReinterpretAsLinear))
|
||||
.Method("ToHex", MakeFunction(&FColor::ToHex))
|
||||
.Method("ToString", MakeFunction(&FColor::ToString))
|
||||
.Method("InitFromString", MakeFunction(&FColor::InitFromString))
|
||||
.Method("ToPackedARGB", MakeFunction(&FColor::ToPackedARGB))
|
||||
.Method("ToPackedABGR", MakeFunction(&FColor::ToPackedABGR))
|
||||
.Method("ToPackedRGBA", MakeFunction(&FColor::ToPackedRGBA))
|
||||
.Method("ToPackedBGRA", MakeFunction(&FColor::ToPackedBGRA))
|
||||
.Variable("White", MakeReadonlyVariable(&FColor::White))
|
||||
.Variable("Black", MakeReadonlyVariable(&FColor::Black))
|
||||
.Variable("Transparent", MakeReadonlyVariable(&FColor::Transparent))
|
||||
.Variable("Red", MakeReadonlyVariable(&FColor::Red))
|
||||
.Variable("Green", MakeReadonlyVariable(&FColor::Green))
|
||||
.Variable("Blue", MakeReadonlyVariable(&FColor::Blue))
|
||||
.Variable("Yellow", MakeReadonlyVariable(&FColor::Yellow))
|
||||
.Variable("Cyan", MakeReadonlyVariable(&FColor::Cyan))
|
||||
.Variable("Magenta", MakeReadonlyVariable(&FColor::Magenta))
|
||||
.Variable("Orange", MakeReadonlyVariable(&FColor::Orange))
|
||||
.Variable("Purple", MakeReadonlyVariable(&FColor::Purple))
|
||||
.Variable("Turquoise", MakeReadonlyVariable(&FColor::Turquoise))
|
||||
.Variable("Silver", MakeReadonlyVariable(&FColor::Silver))
|
||||
.Variable("Emerald", MakeReadonlyVariable(&FColor::Emerald))
|
||||
.Register();
|
||||
}
|
||||
};
|
||||
|
||||
AutoRegisterForFColor _AutoRegisterForFColor_;
|
||||
@@ -0,0 +1,41 @@
|
||||
/*
|
||||
* Tencent is pleased to support the open source community by making Puerts available.
|
||||
* Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
|
||||
* Puerts is licensed under the BSD 3-Clause License, except for the third-party components listed in the file 'LICENSE' which may
|
||||
* be subject to their corresponding license terms. This file is subject to the terms and conditions defined in file 'LICENSE',
|
||||
* which is part of this source code package.
|
||||
*/
|
||||
|
||||
// gen by puerts gen tools
|
||||
|
||||
#include "CoreMinimal.h"
|
||||
#include "UsingTypeDecl.hpp"
|
||||
|
||||
struct AutoRegisterForFGuid
|
||||
{
|
||||
AutoRegisterForFGuid()
|
||||
{
|
||||
puerts::DefineClass<FGuid>()
|
||||
.Constructor(CombineConstructors(MakeConstructor(FGuid), MakeConstructor(FGuid, uint32, uint32, uint32, uint32)))
|
||||
.Property("A", MakeProperty(&FGuid::A))
|
||||
.Property("B", MakeProperty(&FGuid::B))
|
||||
.Property("C", MakeProperty(&FGuid::C))
|
||||
.Property("D", MakeProperty(&FGuid::D))
|
||||
.Method("set_Item", SelectFunction(uint32 & (FGuid::*) (int32), &FGuid::operator[]))
|
||||
.Method("get_Item", SelectFunction(const uint32& (FGuid::*) (int32) const, &FGuid::operator[]))
|
||||
.Method("Invalidate", MakeFunction(&FGuid::Invalidate))
|
||||
.Method("IsValid", MakeFunction(&FGuid::IsValid))
|
||||
#if ENGINE_MAJOR_VERSION >= 5 && ENGINE_MINOR_VERSION > 2
|
||||
.Method("ToString", MakeFunction(&FGuid::ToString, EGuidFormats::Digits))
|
||||
#else
|
||||
.Method("ToString", CombineOverloads(MakeOverload(FString(FGuid::*)() const, &FGuid::ToString),
|
||||
MakeOverload(FString(FGuid::*)(EGuidFormats Format) const, &FGuid::ToString)))
|
||||
#endif
|
||||
.Function("NewGuid", MakeFunction(&FGuid::NewGuid))
|
||||
.Function("Parse", MakeFunction(&FGuid::Parse))
|
||||
.Function("ParseExact", MakeFunction(&FGuid::ParseExact))
|
||||
.Register();
|
||||
}
|
||||
};
|
||||
|
||||
AutoRegisterForFGuid _AutoRegisterForFGuid_;
|
||||
@@ -0,0 +1,51 @@
|
||||
/*
|
||||
* Tencent is pleased to support the open source community by making Puerts available.
|
||||
* Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
|
||||
* Puerts is licensed under the BSD 3-Clause License, except for the third-party components listed in the file 'LICENSE' which may
|
||||
* be subject to their corresponding license terms. This file is subject to the terms and conditions defined in file 'LICENSE',
|
||||
* which is part of this source code package.
|
||||
*/
|
||||
|
||||
// gen by puerts gen tools
|
||||
|
||||
#include "CoreMinimal.h"
|
||||
#include "UsingTypeDecl.hpp"
|
||||
|
||||
struct AutoRegisterForFIntPoint
|
||||
{
|
||||
AutoRegisterForFIntPoint()
|
||||
{
|
||||
puerts::DefineClass<FIntPoint>()
|
||||
.Constructor(CombineConstructors(
|
||||
MakeConstructor(FIntPoint), MakeConstructor(FIntPoint, int32, int32), MakeConstructor(FIntPoint, EForceInit)))
|
||||
.Property("X", MakeProperty(&FIntPoint::X))
|
||||
.Property("Y", MakeProperty(&FIntPoint::Y))
|
||||
.Method("op_Equality", MakeFunction(&FIntPoint::operator==))
|
||||
.Method("op_Inequality", MakeFunction(&FIntPoint::operator!=))
|
||||
.Method("op_Multiply", SelectFunction(FIntPoint(FIntPoint::*)(int32 Scale) const, &FIntPoint::operator*))
|
||||
.Method("op_Division", CombineOverloads(MakeOverload(FIntPoint(FIntPoint::*)(int32) const, &FIntPoint::operator/),
|
||||
MakeOverload(FIntPoint(FIntPoint::*)(const FIntPoint&) const, &FIntPoint::operator/)))
|
||||
.Method("op_Addition", MakeFunction(&FIntPoint::operator+))
|
||||
.Method("op_Subtraction", MakeFunction(&FIntPoint::operator-))
|
||||
.Method("set_Item", SelectFunction(int32 & (FIntPoint::*) (int32), &FIntPoint::operator[]))
|
||||
.Method("get_Item", SelectFunction(int32(FIntPoint::*)(int32) const, &FIntPoint::operator[]))
|
||||
.Method("ComponentMin", MakeFunction(&FIntPoint::ComponentMin))
|
||||
.Method("ComponentMax", MakeFunction(&FIntPoint::ComponentMax))
|
||||
.Method("GetMax", MakeFunction(&FIntPoint::GetMax))
|
||||
.Method("GetMin", MakeFunction(&FIntPoint::GetMin))
|
||||
.Method("Size", MakeFunction(&FIntPoint::Size))
|
||||
.Method("SizeSquared", MakeFunction(&FIntPoint::SizeSquared))
|
||||
.Method("ToString", MakeFunction(&FIntPoint::ToString))
|
||||
.Function(
|
||||
"DivideAndRoundUp", CombineOverloads(MakeOverload(FIntPoint(*)(FIntPoint, int32), &FIntPoint::DivideAndRoundUp),
|
||||
MakeOverload(FIntPoint(*)(FIntPoint, FIntPoint), &FIntPoint::DivideAndRoundUp)))
|
||||
.Function(
|
||||
"DivideAndRoundDown", SelectFunction(FIntPoint(*)(FIntPoint lhs, int32 Divisor), &FIntPoint::DivideAndRoundDown))
|
||||
.Function("Num", MakeFunction(&FIntPoint::Num))
|
||||
.Variable("ZeroValue", MakeReadonlyVariable(&FIntPoint::ZeroValue))
|
||||
.Variable("NoneValue", MakeReadonlyVariable(&FIntPoint::NoneValue))
|
||||
.Register();
|
||||
}
|
||||
};
|
||||
|
||||
AutoRegisterForFIntPoint _AutoRegisterForFIntPoint_;
|
||||
@@ -0,0 +1,47 @@
|
||||
/*
|
||||
* Tencent is pleased to support the open source community by making Puerts available.
|
||||
* Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
|
||||
* Puerts is licensed under the BSD 3-Clause License, except for the third-party components listed in the file 'LICENSE' which may
|
||||
* be subject to their corresponding license terms. This file is subject to the terms and conditions defined in file 'LICENSE',
|
||||
* which is part of this source code package.
|
||||
*/
|
||||
|
||||
// gen by puerts gen tools
|
||||
|
||||
#include "CoreMinimal.h"
|
||||
#include "UsingTypeDecl.hpp"
|
||||
|
||||
struct AutoRegisterForFIntVector
|
||||
{
|
||||
AutoRegisterForFIntVector()
|
||||
{
|
||||
puerts::DefineClass<FIntVector>()
|
||||
.Constructor(CombineConstructors(MakeConstructor(FIntVector), MakeConstructor(FIntVector, int32, int32, int32),
|
||||
MakeConstructor(FIntVector, int32), MakeConstructor(FIntVector, FVector), MakeConstructor(FIntVector, EForceInit)))
|
||||
.Property("X", MakeProperty(&FIntVector::X))
|
||||
.Property("Y", MakeProperty(&FIntVector::Y))
|
||||
.Property("Z", MakeProperty(&FIntVector::Z))
|
||||
.Method("get_Item", SelectFunction(const int32& (FIntVector::*) (int32) const, &FIntVector::operator[]))
|
||||
.Method("set_Item", SelectFunction(int32 & (FIntVector::*) (int32), &FIntVector::operator[]))
|
||||
.Method("op_Equality", MakeFunction(&FIntVector::operator==))
|
||||
.Method("op_Inequality", MakeFunction(&FIntVector::operator!=))
|
||||
.Method("op_Multiply", SelectFunction(FIntVector(FIntVector::*)(int32 Scale) const, &FIntVector::operator*))
|
||||
.Method("op_Division", MakeFunction(&FIntVector::operator/))
|
||||
.Method("op_Addition", MakeFunction(&FIntVector::operator+))
|
||||
.Method("op_Subtraction", MakeFunction(&FIntVector::operator-))
|
||||
.Method("IsZero", MakeFunction(&FIntVector::IsZero))
|
||||
.Method("GetMax", MakeFunction(&FIntVector::GetMax))
|
||||
.Method("GetMin", MakeFunction(&FIntVector::GetMin))
|
||||
.Method("Size", MakeFunction(&FIntVector::Size))
|
||||
.Method("ToString", MakeFunction(&FIntVector::ToString))
|
||||
.Function(
|
||||
"DivideAndRoundUp", CombineOverloads(MakeOverload(FIntVector(*)(FIntVector, int32), &FIntVector::DivideAndRoundUp),
|
||||
MakeOverload(FIntVector(*)(FIntVector, FIntVector), &FIntVector::DivideAndRoundUp)))
|
||||
.Function("Num", MakeFunction(&FIntVector::Num))
|
||||
.Variable("ZeroValue", MakeReadonlyVariable(&FIntVector::ZeroValue))
|
||||
.Variable("NoneValue", MakeReadonlyVariable(&FIntVector::NoneValue))
|
||||
.Register();
|
||||
}
|
||||
};
|
||||
|
||||
AutoRegisterForFIntVector _AutoRegisterForFIntVector_;
|
||||
@@ -0,0 +1,84 @@
|
||||
/*
|
||||
* Tencent is pleased to support the open source community by making Puerts available.
|
||||
* Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
|
||||
* Puerts is licensed under the BSD 3-Clause License, except for the third-party components listed in the file 'LICENSE' which may
|
||||
* be subject to their corresponding license terms. This file is subject to the terms and conditions defined in file 'LICENSE',
|
||||
* which is part of this source code package.
|
||||
*/
|
||||
|
||||
// gen by puerts gen tools
|
||||
|
||||
#include "CoreMinimal.h"
|
||||
#include "UsingTypeDecl.hpp"
|
||||
|
||||
__DefCDataConverter(FFloat16Color);
|
||||
|
||||
struct AutoRegisterForFLinearColor
|
||||
{
|
||||
AutoRegisterForFLinearColor()
|
||||
{
|
||||
puerts::DefineClass<FFloat16Color>().Register();
|
||||
|
||||
puerts::DefineClass<FLinearColor>()
|
||||
.Constructor(CombineConstructors(MakeConstructor(FLinearColor), MakeConstructor(FLinearColor, EForceInit),
|
||||
MakeConstructor(FLinearColor, float, float, float, float), MakeConstructor(FLinearColor, const FColor&),
|
||||
MakeConstructor(FLinearColor, const FVector&), MakeConstructor(FLinearColor, const FVector4&),
|
||||
MakeConstructor(FLinearColor, const FFloat16Color&)))
|
||||
.Property("R", MakeProperty(&FLinearColor::R))
|
||||
.Property("G", MakeProperty(&FLinearColor::G))
|
||||
.Property("B", MakeProperty(&FLinearColor::B))
|
||||
.Property("A", MakeProperty(&FLinearColor::A))
|
||||
.Method("ToRGBE", MakeFunction(&FLinearColor::ToRGBE))
|
||||
.Function("FromSRGBColor", MakeFunction(&FLinearColor::FromSRGBColor))
|
||||
.Function("FromPow22Color", MakeFunction(&FLinearColor::FromPow22Color))
|
||||
.Method("Component", CombineOverloads(MakeOverload(float& (FLinearColor::*) (int32), &FLinearColor::Component),
|
||||
MakeOverload(const float& (FLinearColor::*) (int32) const, &FLinearColor::Component)))
|
||||
.Method("op_Addition", MakeFunction(&FLinearColor::operator+))
|
||||
.Method("op_Subtraction", MakeFunction(&FLinearColor::operator-))
|
||||
.Method("op_Multiply",
|
||||
CombineOverloads(MakeOverload(FLinearColor(FLinearColor::*)(const FLinearColor&) const, &FLinearColor::operator*),
|
||||
MakeOverload(FLinearColor(FLinearColor::*)(float) const, &FLinearColor::operator*)))
|
||||
.Method("op_Division",
|
||||
CombineOverloads(MakeOverload(FLinearColor(FLinearColor::*)(const FLinearColor&) const, &FLinearColor::operator/),
|
||||
MakeOverload(FLinearColor(FLinearColor::*)(float) const, &FLinearColor::operator/)))
|
||||
.Method("GetClamped", MakeFunction(&FLinearColor::GetClamped))
|
||||
.Method("op_Equality", MakeFunction(&FLinearColor::operator==))
|
||||
.Method("op_Inequality", MakeFunction(&FLinearColor::operator!=))
|
||||
.Method("Equals", MakeFunction(&FLinearColor::Equals, SMALL_NUMBER))
|
||||
.Method("CopyWithNewOpacity", MakeFunction(&FLinearColor::CopyWithNewOpacity))
|
||||
.Function("MakeRandomColor", MakeFunction(&FLinearColor::MakeRandomColor))
|
||||
.Function("MakeFromColorTemperature", MakeFunction(&FLinearColor::MakeFromColorTemperature))
|
||||
.Function("Dist", MakeFunction(&FLinearColor::Dist))
|
||||
.Method("LinearRGBToHSV", MakeFunction(&FLinearColor::LinearRGBToHSV))
|
||||
.Method("HSVToLinearRGB", MakeFunction(&FLinearColor::HSVToLinearRGB))
|
||||
.Function("LerpUsingHSV", MakeFunction(&FLinearColor::LerpUsingHSV))
|
||||
.Method("Quantize", MakeFunction(&FLinearColor::Quantize))
|
||||
.Method("QuantizeRound", MakeFunction(&FLinearColor::QuantizeRound))
|
||||
.Method("ToFColor", MakeFunction(&FLinearColor::ToFColor))
|
||||
.Method("Desaturate", MakeFunction(&FLinearColor::Desaturate))
|
||||
#if ENGINE_MAJOR_VERSION > 4
|
||||
.Method("ComputeLuminance", MakeFunction(&FLinearColor::GetLuminance))
|
||||
#else
|
||||
.Method("ComputeLuminance", MakeFunction(&FLinearColor::ComputeLuminance))
|
||||
#endif
|
||||
.Method("GetMax", MakeFunction(&FLinearColor::GetMax))
|
||||
.Method("IsAlmostBlack", MakeFunction(&FLinearColor::IsAlmostBlack))
|
||||
.Method("GetMin", MakeFunction(&FLinearColor::GetMin))
|
||||
.Method("GetLuminance", MakeFunction(&FLinearColor::GetLuminance))
|
||||
.Method("ToString", MakeFunction(&FLinearColor::ToString))
|
||||
.Method("InitFromString", MakeFunction(&FLinearColor::InitFromString))
|
||||
//.Variable("Pow22OneOver255Table", MakeVariable(&FLinearColor::Pow22OneOver255Table))
|
||||
//.Variable("sRGBToLinearTable", MakeVariable(&FLinearColor::sRGBToLinearTable))
|
||||
.Variable("White", MakeReadonlyVariable(&FLinearColor::White))
|
||||
.Variable("Gray", MakeReadonlyVariable(&FLinearColor::Gray))
|
||||
.Variable("Black", MakeReadonlyVariable(&FLinearColor::Black))
|
||||
.Variable("Transparent", MakeReadonlyVariable(&FLinearColor::Transparent))
|
||||
.Variable("Red", MakeReadonlyVariable(&FLinearColor::Red))
|
||||
.Variable("Green", MakeReadonlyVariable(&FLinearColor::Green))
|
||||
.Variable("Blue", MakeReadonlyVariable(&FLinearColor::Blue))
|
||||
.Variable("Yellow", MakeReadonlyVariable(&FLinearColor::Yellow))
|
||||
.Register();
|
||||
}
|
||||
};
|
||||
|
||||
AutoRegisterForFLinearColor _AutoRegisterForFLinearColor_;
|
||||
@@ -0,0 +1,87 @@
|
||||
/*
|
||||
* Tencent is pleased to support the open source community by making Puerts available.
|
||||
* Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
|
||||
* Puerts is licensed under the BSD 3-Clause License, except for the third-party components listed in the file 'LICENSE' which may
|
||||
* be subject to their corresponding license terms. This file is subject to the terms and conditions defined in file 'LICENSE',
|
||||
* which is part of this source code package.
|
||||
*/
|
||||
|
||||
// gen by puerts gen tools
|
||||
|
||||
#include "CoreMinimal.h"
|
||||
#include "UsingTypeDecl.hpp"
|
||||
|
||||
struct AutoRegisterForFQuat
|
||||
{
|
||||
AutoRegisterForFQuat()
|
||||
{
|
||||
puerts::DefineClass<FQuat>()
|
||||
.Constructor(CombineConstructors(MakeConstructor(FQuat), MakeConstructor(FQuat, EForceInit),
|
||||
MakeConstructor(FQuat, float, float, float, float), MakeConstructor(FQuat, const FMatrix&),
|
||||
MakeConstructor(FQuat, const FRotator&), MakeConstructor(FQuat, FVector, float)))
|
||||
.Property("X", MakeProperty(&FQuat::X))
|
||||
.Property("Y", MakeProperty(&FQuat::Y))
|
||||
.Property("Z", MakeProperty(&FQuat::Z))
|
||||
.Property("W", MakeProperty(&FQuat::W))
|
||||
.Method("op_Addition", MakeFunction(&FQuat::operator+))
|
||||
.Method("op_Subtraction", SelectFunction(FQuat(FQuat::*)(const FQuat& Q) const, &FQuat::operator-))
|
||||
.Method("Equals", MakeFunction(&FQuat::Equals, KINDA_SMALL_NUMBER))
|
||||
.Method("IsIdentity", MakeFunction(&FQuat::IsIdentity, SMALL_NUMBER))
|
||||
.Method("op_Multiply", CombineOverloads(MakeOverload(FQuat(FQuat::*)(const FQuat&) const, &FQuat::operator*),
|
||||
MakeOverload(FVector(FQuat::*)(const FVector&) const, &FQuat::operator*),
|
||||
MakeOverload(FQuat(FQuat::*)(const float) const, &FQuat::operator*)))
|
||||
.Method("op_Division", SelectFunction(FQuat(FQuat::*)(const float Scale) const, &FQuat::operator/))
|
||||
.Method("op_Equality", MakeFunction(&FQuat::operator==))
|
||||
.Method("op_Inequality", MakeFunction(&FQuat::operator!=))
|
||||
.Method("op_BitwiseOr", MakeFunction(&FQuat::operator|))
|
||||
.Function("MakeFromEuler", MakeFunction(&FQuat::MakeFromEuler))
|
||||
.Method("Euler", MakeFunction(&FQuat::Euler))
|
||||
.Method("Normalize", MakeFunction(&FQuat::Normalize, SMALL_NUMBER))
|
||||
.Method("GetNormalized", MakeFunction(&FQuat::GetNormalized, SMALL_NUMBER))
|
||||
.Method("IsNormalized", MakeFunction(&FQuat::IsNormalized))
|
||||
.Method("Size", MakeFunction(&FQuat::Size))
|
||||
.Method("SizeSquared", MakeFunction(&FQuat::SizeSquared))
|
||||
.Method("GetAngle", MakeFunction(&FQuat::GetAngle))
|
||||
.Method("ToAxisAndAngle", SelectFunction(void (FQuat::*)(FVector & Axis, float& Angle) const, &FQuat::ToAxisAndAngle))
|
||||
.Method("ToSwingTwist", MakeFunction(&FQuat::ToSwingTwist))
|
||||
.Method("RotateVector", MakeFunction(&FQuat::RotateVector))
|
||||
.Method("UnrotateVector", MakeFunction(&FQuat::UnrotateVector))
|
||||
.Method("Log", MakeFunction(&FQuat::Log))
|
||||
.Method("Exp", MakeFunction(&FQuat::Exp))
|
||||
.Method("Inverse", MakeFunction(&FQuat::Inverse))
|
||||
.Method("EnforceShortestArcWith", MakeFunction(&FQuat::EnforceShortestArcWith))
|
||||
.Method("GetAxisX", MakeFunction(&FQuat::GetAxisX))
|
||||
.Method("GetAxisY", MakeFunction(&FQuat::GetAxisY))
|
||||
.Method("GetAxisZ", MakeFunction(&FQuat::GetAxisZ))
|
||||
.Method("GetForwardVector", MakeFunction(&FQuat::GetForwardVector))
|
||||
.Method("GetRightVector", MakeFunction(&FQuat::GetRightVector))
|
||||
.Method("GetUpVector", MakeFunction(&FQuat::GetUpVector))
|
||||
.Method("Vector", MakeFunction(&FQuat::Vector))
|
||||
.Method("Rotator", MakeFunction(&FQuat::Rotator))
|
||||
.Method("GetRotationAxis", MakeFunction(&FQuat::GetRotationAxis))
|
||||
.Method("AngularDistance", MakeFunction(&FQuat::AngularDistance))
|
||||
.Method("ContainsNaN", MakeFunction(&FQuat::ContainsNaN))
|
||||
.Method("ToString", MakeFunction(&FQuat::ToString))
|
||||
.Method("InitFromString", MakeFunction(&FQuat::InitFromString))
|
||||
.Method("DiagnosticCheckNaN", CombineOverloads(MakeOverload(void (FQuat::*)() const, &FQuat::DiagnosticCheckNaN),
|
||||
MakeOverload(void (FQuat::*)(const TCHAR*) const, &FQuat::DiagnosticCheckNaN)))
|
||||
.Function("FindBetween", MakeFunction(&FQuat::FindBetween))
|
||||
.Function("FindBetweenNormals", MakeFunction(&FQuat::FindBetweenNormals))
|
||||
.Function("FindBetweenVectors", MakeFunction(&FQuat::FindBetweenVectors))
|
||||
.Function("Error", MakeFunction(&FQuat::Error))
|
||||
.Function("ErrorAutoNormalize", MakeFunction(&FQuat::ErrorAutoNormalize))
|
||||
.Function("FastLerp", MakeFunction(&FQuat::FastLerp))
|
||||
.Function("FastBilerp", MakeFunction(&FQuat::FastBilerp))
|
||||
.Function("Slerp_NotNormalized", MakeFunction(&FQuat::Slerp_NotNormalized))
|
||||
.Function("Slerp", MakeFunction(&FQuat::Slerp))
|
||||
.Function("SlerpFullPath_NotNormalized", MakeFunction(&FQuat::SlerpFullPath_NotNormalized))
|
||||
.Function("SlerpFullPath", MakeFunction(&FQuat::SlerpFullPath))
|
||||
.Function("Squad", MakeFunction(&FQuat::Squad))
|
||||
.Function("SquadFullPath", MakeFunction(&FQuat::SquadFullPath))
|
||||
.Function("CalcTangents", MakeFunction(&FQuat::CalcTangents))
|
||||
.Variable("Identity", MakeReadonlyVariable(&FQuat::Identity))
|
||||
.Register();
|
||||
}
|
||||
};
|
||||
|
||||
AutoRegisterForFQuat _AutoRegisterForFQuat_;
|
||||
@@ -0,0 +1,69 @@
|
||||
/*
|
||||
* Tencent is pleased to support the open source community by making Puerts available.
|
||||
* Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
|
||||
* Puerts is licensed under the BSD 3-Clause License, except for the third-party components listed in the file 'LICENSE' which may
|
||||
* be subject to their corresponding license terms. This file is subject to the terms and conditions defined in file 'LICENSE',
|
||||
* which is part of this source code package.
|
||||
*/
|
||||
|
||||
// gen by puerts gen tools
|
||||
|
||||
#include "CoreMinimal.h"
|
||||
#include "UsingTypeDecl.hpp"
|
||||
|
||||
struct AutoRegisterForFRotator
|
||||
{
|
||||
AutoRegisterForFRotator()
|
||||
{
|
||||
puerts::DefineClass<FRotator>()
|
||||
.Constructor(CombineConstructors(MakeConstructor(FRotator), MakeConstructor(FRotator, float),
|
||||
MakeConstructor(FRotator, float, float, float), MakeConstructor(FRotator, EForceInit),
|
||||
MakeConstructor(FRotator, const FQuat&)))
|
||||
.Property("Pitch", MakeProperty(&FRotator::Pitch))
|
||||
.Property("Yaw", MakeProperty(&FRotator::Yaw))
|
||||
.Property("Roll", MakeProperty(&FRotator::Roll))
|
||||
.Method("DiagnosticCheckNaN", CombineOverloads(MakeOverload(void (FRotator::*)() const, &FRotator::DiagnosticCheckNaN),
|
||||
MakeOverload(void (FRotator::*)(const TCHAR*) const, &FRotator::DiagnosticCheckNaN)))
|
||||
.Method("op_Addition", MakeFunction(&FRotator::operator+))
|
||||
.Method("op_Subtraction", MakeFunction(&FRotator::operator-))
|
||||
.Method("op_Multiply", SelectFunction(FRotator(FRotator::*)(float Scale) const, &FRotator::operator*))
|
||||
.Method("op_Equality", MakeFunction(&FRotator::operator==))
|
||||
.Method("op_Inequality", MakeFunction(&FRotator::operator!=))
|
||||
.Method("IsNearlyZero", MakeFunction(&FRotator::IsNearlyZero))
|
||||
.Method("IsZero", MakeFunction(&FRotator::IsZero))
|
||||
.Method("Equals", MakeFunction(&FRotator::Equals, KINDA_SMALL_NUMBER))
|
||||
.Method("Add", MakeFunction(&FRotator::Add))
|
||||
.Method("GetInverse", MakeFunction(&FRotator::GetInverse))
|
||||
.Method("GridSnap", MakeFunction(&FRotator::GridSnap))
|
||||
.Method("Vector", MakeFunction(&FRotator::Vector))
|
||||
.Method("Quaternion", MakeFunction(&FRotator::Quaternion))
|
||||
.Method("Euler", MakeFunction(&FRotator::Euler))
|
||||
.Method("RotateVector", MakeFunction(&FRotator::RotateVector))
|
||||
.Method("UnrotateVector", MakeFunction(&FRotator::UnrotateVector))
|
||||
.Method("Clamp", MakeFunction(&FRotator::Clamp))
|
||||
.Method("GetNormalized", MakeFunction(&FRotator::GetNormalized))
|
||||
.Method("GetDenormalized", MakeFunction(&FRotator::GetDenormalized))
|
||||
.Method("GetComponentForAxis", MakeFunction(&FRotator::GetComponentForAxis))
|
||||
.Method("SetComponentForAxis", MakeFunction(&FRotator::SetComponentForAxis))
|
||||
.Method("Normalize", MakeFunction(&FRotator::Normalize))
|
||||
.Method("GetWindingAndRemainder", MakeFunction(&FRotator::GetWindingAndRemainder))
|
||||
.Method("GetManhattanDistance", MakeFunction(&FRotator::GetManhattanDistance))
|
||||
.Method("GetEquivalentRotator", MakeFunction(&FRotator::GetEquivalentRotator))
|
||||
.Method("SetClosestToMe", MakeFunction(&FRotator::SetClosestToMe))
|
||||
.Method("ToString", MakeFunction(&FRotator::ToString))
|
||||
.Method("ToCompactString", MakeFunction(&FRotator::ToCompactString))
|
||||
.Method("InitFromString", MakeFunction(&FRotator::InitFromString))
|
||||
.Method("ContainsNaN", MakeFunction(&FRotator::ContainsNaN))
|
||||
.Function("ClampAxis", MakeFunction(&FRotator::ClampAxis))
|
||||
.Function("NormalizeAxis", MakeFunction(&FRotator::NormalizeAxis))
|
||||
.Function("CompressAxisToByte", MakeFunction(&FRotator::CompressAxisToByte))
|
||||
.Function("DecompressAxisFromByte", MakeFunction(&FRotator::DecompressAxisFromByte))
|
||||
.Function("CompressAxisToShort", MakeFunction(&FRotator::CompressAxisToShort))
|
||||
.Function("DecompressAxisFromShort", MakeFunction(&FRotator::DecompressAxisFromShort))
|
||||
.Function("MakeFromEuler", MakeFunction(&FRotator::MakeFromEuler))
|
||||
.Variable("ZeroRotator", MakeReadonlyVariable(&FRotator::ZeroRotator))
|
||||
.Register();
|
||||
}
|
||||
};
|
||||
|
||||
AutoRegisterForFRotator _AutoRegisterForFRotator_;
|
||||
@@ -0,0 +1,122 @@
|
||||
/*
|
||||
* Tencent is pleased to support the open source community by making Puerts available.
|
||||
* Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
|
||||
* Puerts is licensed under the BSD 3-Clause License, except for the third-party components listed in the file 'LICENSE' which may
|
||||
* be subject to their corresponding license terms. This file is subject to the terms and conditions defined in file 'LICENSE',
|
||||
* which is part of this source code package.
|
||||
*/
|
||||
|
||||
// gen by puerts gen tools
|
||||
|
||||
#include "CoreMinimal.h"
|
||||
#include "UsingTypeDecl.hpp"
|
||||
|
||||
struct AutoRegisterForFTransform
|
||||
{
|
||||
AutoRegisterForFTransform()
|
||||
{
|
||||
puerts::DefineClass<FTransform>()
|
||||
.Constructor(CombineConstructors(MakeConstructor(FTransform), MakeConstructor(FTransform, const FVector&),
|
||||
MakeConstructor(FTransform, const FQuat&), MakeConstructor(FTransform, const FRotator&),
|
||||
MakeConstructor(FTransform, const FQuat&, const FVector&, const FVector&),
|
||||
MakeConstructor(FTransform, const FRotator&, const FVector&, const FVector&), MakeConstructor(FTransform, ENoInit),
|
||||
MakeConstructor(FTransform, const FMatrix&),
|
||||
MakeConstructor(FTransform, const FVector&, const FVector&, const FVector&, const FVector&)))
|
||||
.Method("DiagnosticCheckNaN_Translate", MakeFunction(&FTransform::DiagnosticCheckNaN_Translate))
|
||||
.Method("DiagnosticCheckNaN_Rotate", MakeFunction(&FTransform::DiagnosticCheckNaN_Rotate))
|
||||
.Method("DiagnosticCheckNaN_Scale3D", MakeFunction(&FTransform::DiagnosticCheckNaN_Scale3D))
|
||||
.Method("DiagnosticCheckNaN_All", MakeFunction(&FTransform::DiagnosticCheckNaN_All))
|
||||
.Method("DiagnosticCheck_IsValid", MakeFunction(&FTransform::DiagnosticCheck_IsValid))
|
||||
.Method("DebugPrint", MakeFunction(&FTransform::DebugPrint))
|
||||
.Method("ToHumanReadableString", MakeFunction(&FTransform::ToHumanReadableString))
|
||||
.Method("ToString", MakeFunction(&FTransform::ToString))
|
||||
.Method("InitFromString", MakeFunction(&FTransform::InitFromString))
|
||||
.Method("Inverse", MakeFunction(&FTransform::Inverse))
|
||||
.Method("Blend", MakeFunction(&FTransform::Blend))
|
||||
.Method("BlendWith", MakeFunction(&FTransform::BlendWith))
|
||||
.Method("op_Addition", MakeFunction(&FTransform::operator+))
|
||||
.Method("op_Multiply",
|
||||
CombineOverloads(MakeOverload(FTransform(FTransform::*)(const FTransform&) const, &FTransform::operator*),
|
||||
MakeOverload(FTransform(FTransform::*)(const FQuat&) const, &FTransform::operator*)))
|
||||
.Function("AnyHasNegativeScale", MakeFunction(&FTransform::AnyHasNegativeScale))
|
||||
.Method("RemoveScaling", MakeFunction(&FTransform::RemoveScaling, SMALL_NUMBER))
|
||||
.Method("GetMaximumAxisScale", MakeFunction(&FTransform::GetMaximumAxisScale))
|
||||
.Method("GetMinimumAxisScale", MakeFunction(&FTransform::GetMinimumAxisScale))
|
||||
.Method("GetRelativeTransform", MakeFunction(&FTransform::GetRelativeTransform))
|
||||
.Method("GetRelativeTransformReverse", MakeFunction(&FTransform::GetRelativeTransformReverse))
|
||||
.Method("SetToRelativeTransform", MakeFunction(&FTransform::SetToRelativeTransform))
|
||||
.Method("TransformFVector4", MakeFunction(&FTransform::TransformFVector4))
|
||||
.Method("TransformFVector4NoScale", MakeFunction(&FTransform::TransformFVector4NoScale))
|
||||
.Method("TransformPosition", MakeFunction(&FTransform::TransformPosition))
|
||||
.Method("TransformPositionNoScale", MakeFunction(&FTransform::TransformPositionNoScale))
|
||||
.Method("InverseTransformPosition", MakeFunction(&FTransform::InverseTransformPosition))
|
||||
.Method("InverseTransformPositionNoScale", MakeFunction(&FTransform::InverseTransformPositionNoScale))
|
||||
.Method("TransformVector", MakeFunction(&FTransform::TransformVector))
|
||||
.Method("TransformVectorNoScale", MakeFunction(&FTransform::TransformVectorNoScale))
|
||||
.Method("InverseTransformVector", MakeFunction(&FTransform::InverseTransformVector))
|
||||
.Method("InverseTransformVectorNoScale", MakeFunction(&FTransform::InverseTransformVectorNoScale))
|
||||
.Method("TransformRotation", MakeFunction(&FTransform::TransformRotation))
|
||||
.Method("InverseTransformRotation", MakeFunction(&FTransform::InverseTransformRotation))
|
||||
#if ENGINE_MAJOR_VERSION >= 5 && ENGINE_MINOR_VERSION > 2
|
||||
.Method("ScaleTranslation",
|
||||
CombineOverloads(MakeOverload(void (FTransform::*)(const FVector&), &FTransform::ScaleTranslation),
|
||||
MakeOverload(void (FTransform::*)(const double&), &FTransform::ScaleTranslation)))
|
||||
.Method("GetScaled", CombineOverloads(MakeOverload(FTransform(FTransform::*)(double) const, &FTransform::GetScaled),
|
||||
MakeOverload(FTransform(FTransform::*)(FVector) const, &FTransform::GetScaled)))
|
||||
.Function("GetSafeScaleReciprocal",
|
||||
SelectFunction(FVector(*)(const FVector&, double), &FTransform::GetSafeScaleReciprocal, SMALL_NUMBER))
|
||||
#else
|
||||
.Method("ScaleTranslation",
|
||||
CombineOverloads(MakeOverload(void (FTransform::*)(const FVector&), &FTransform::ScaleTranslation),
|
||||
MakeOverload(void (FTransform::*)(const float&), &FTransform::ScaleTranslation)))
|
||||
.Method("GetScaled", CombineOverloads(MakeOverload(FTransform(FTransform::*)(float) const, &FTransform::GetScaled),
|
||||
MakeOverload(FTransform(FTransform::*)(FVector) const, &FTransform::GetScaled)))
|
||||
.Function("GetSafeScaleReciprocal",
|
||||
SelectFunction(FVector(*)(const FVector&, float), &FTransform::GetSafeScaleReciprocal, SMALL_NUMBER))
|
||||
#endif
|
||||
.Method("GetScaledAxis", MakeFunction(&FTransform::GetScaledAxis))
|
||||
.Method("GetUnitAxis", MakeFunction(&FTransform::GetUnitAxis))
|
||||
.Method("Mirror", MakeFunction(&FTransform::Mirror))
|
||||
.Method("GetLocation", MakeFunction(&FTransform::GetLocation))
|
||||
.Method("Rotator", MakeFunction(&FTransform::Rotator))
|
||||
.Method("GetDeterminant", MakeFunction(&FTransform::GetDeterminant))
|
||||
.Method("SetLocation", MakeFunction(&FTransform::SetLocation))
|
||||
.Method("ContainsNaN", MakeFunction(&FTransform::ContainsNaN))
|
||||
.Method("IsValid", MakeFunction(&FTransform::IsValid))
|
||||
.Function("AreRotationsEqual", MakeFunction(&FTransform::AreRotationsEqual, KINDA_SMALL_NUMBER))
|
||||
.Function("AreTranslationsEqual", MakeFunction(&FTransform::AreTranslationsEqual, KINDA_SMALL_NUMBER))
|
||||
.Function("AreScale3DsEqual", MakeFunction(&FTransform::AreScale3DsEqual, KINDA_SMALL_NUMBER))
|
||||
.Method("RotationEquals", MakeFunction(&FTransform::RotationEquals, KINDA_SMALL_NUMBER))
|
||||
.Method("TranslationEquals", MakeFunction(&FTransform::TranslationEquals, KINDA_SMALL_NUMBER))
|
||||
.Method("Scale3DEquals", MakeFunction(&FTransform::Scale3DEquals, KINDA_SMALL_NUMBER))
|
||||
.Method("Equals", MakeFunction(&FTransform::Equals, KINDA_SMALL_NUMBER))
|
||||
.Method("EqualsNoScale", MakeFunction(&FTransform::EqualsNoScale, KINDA_SMALL_NUMBER))
|
||||
.Function("Multiply", MakeFunction(&FTransform::Multiply))
|
||||
.Method("SetComponents", MakeFunction(&FTransform::SetComponents))
|
||||
.Method("SetIdentity", MakeFunction(&FTransform::SetIdentity))
|
||||
.Method("MultiplyScale3D", MakeFunction(&FTransform::MultiplyScale3D))
|
||||
.Method("SetTranslation", MakeFunction(&FTransform::SetTranslation))
|
||||
.Method("CopyTranslation", MakeFunction(&FTransform::CopyTranslation))
|
||||
.Method("ConcatenateRotation", MakeFunction(&FTransform::ConcatenateRotation))
|
||||
.Method("AddToTranslation", MakeFunction(&FTransform::AddToTranslation))
|
||||
.Function("AddTranslations", MakeFunction(&FTransform::AddTranslations))
|
||||
.Function("SubtractTranslations", MakeFunction(&FTransform::SubtractTranslations))
|
||||
.Method("SetRotation", MakeFunction(&FTransform::SetRotation))
|
||||
.Method("CopyRotation", MakeFunction(&FTransform::CopyRotation))
|
||||
.Method("SetScale3D", MakeFunction(&FTransform::SetScale3D))
|
||||
.Method("CopyScale3D", MakeFunction(&FTransform::CopyScale3D))
|
||||
.Method("SetTranslationAndScale3D", MakeFunction(&FTransform::SetTranslationAndScale3D))
|
||||
.Method("Accumulate", SelectFunction(void (FTransform::*)(const FTransform&), &FTransform::Accumulate))
|
||||
.Method("NormalizeRotation", MakeFunction(&FTransform::NormalizeRotation))
|
||||
.Method("IsRotationNormalized", MakeFunction(&FTransform::IsRotationNormalized))
|
||||
.Method("GetRotation", MakeFunction(&FTransform::GetRotation))
|
||||
.Method("GetTranslation", MakeFunction(&FTransform::GetTranslation))
|
||||
.Method("GetScale3D", MakeFunction(&FTransform::GetScale3D))
|
||||
.Method("CopyRotationPart", MakeFunction(&FTransform::CopyRotationPart))
|
||||
.Method("CopyTranslationAndScale3D", MakeFunction(&FTransform::CopyTranslationAndScale3D))
|
||||
.Variable("Identity", MakeReadonlyVariable(&FTransform::Identity))
|
||||
.Register();
|
||||
}
|
||||
};
|
||||
|
||||
AutoRegisterForFTransform _AutoRegisterForFTransform_;
|
||||
@@ -0,0 +1,96 @@
|
||||
/*
|
||||
* Tencent is pleased to support the open source community by making Puerts available.
|
||||
* Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
|
||||
* Puerts is licensed under the BSD 3-Clause License, except for the third-party components listed in the file 'LICENSE' which may
|
||||
* be subject to their corresponding license terms. This file is subject to the terms and conditions defined in file 'LICENSE',
|
||||
* which is part of this source code package.
|
||||
*/
|
||||
|
||||
// gen by puerts gen tools
|
||||
|
||||
#include "CoreMinimal.h"
|
||||
#include "UsingTypeDecl.hpp"
|
||||
|
||||
struct AutoRegisterForFVector2D
|
||||
{
|
||||
AutoRegisterForFVector2D()
|
||||
{
|
||||
puerts::DefineClass<FVector2D>()
|
||||
.Constructor(CombineConstructors(MakeConstructor(FVector2D), MakeConstructor(FVector2D, float, float),
|
||||
MakeConstructor(FVector2D, float), MakeConstructor(FVector2D, FIntPoint), MakeConstructor(FVector2D, EForceInit),
|
||||
MakeConstructor(FVector2D, ENoInit), MakeConstructor(FVector2D, const FVector&),
|
||||
MakeConstructor(FVector2D, const FVector4&)))
|
||||
.Property("X", MakeProperty(&FVector2D::X))
|
||||
.Property("Y", MakeProperty(&FVector2D::Y))
|
||||
.Method("op_BitwiseOr", MakeFunction(&FVector2D::operator|))
|
||||
.Method("op_ExclusiveOr", MakeFunction(&FVector2D::operator^))
|
||||
.Method("op_Equality", MakeFunction(&FVector2D::operator==))
|
||||
.Method("op_Inequality", MakeFunction(&FVector2D::operator!=))
|
||||
.Method("op_UnaryNegation", SelectFunction(FVector2D(FVector2D::*)() const, &FVector2D::operator-))
|
||||
#if ENGINE_MAJOR_VERSION >= 5 && ENGINE_MINOR_VERSION > 2
|
||||
.Method("op_Addition",
|
||||
CombineOverloads(MakeOverload(FVector2D(FVector2D::*)(const FVector2D&) const, &FVector2D::operator+),
|
||||
MakeOverload(FVector2D(FVector2D::*)(double) const, &FVector2D::operator+)))
|
||||
.Method("op_Subtraction",
|
||||
CombineOverloads(MakeOverload(FVector2D(FVector2D::*)(const FVector2D&) const, &FVector2D::operator-),
|
||||
MakeOverload(FVector2D(FVector2D::*)(double) const, &FVector2D::operator-)))
|
||||
.Method("op_Multiply", CombineOverloads(MakeOverload(FVector2D(FVector2D::*)(double) const, &FVector2D::operator*),
|
||||
MakeOverload(FVector2D(FVector2D::*)(const FVector2D&) const, &FVector2D::operator*)))
|
||||
.Method("op_Division", CombineOverloads(MakeOverload(FVector2D(FVector2D::*)(double) const, &FVector2D::operator/),
|
||||
MakeOverload(FVector2D(FVector2D::*)(const FVector2D&) const, &FVector2D::operator/)))
|
||||
.Method("set_Item", SelectFunction(double& (FVector2D::*) (int32), &FVector2D::operator[]))
|
||||
.Method("get_Item", SelectFunction(double (FVector2D::*)(int32) const, &FVector2D::operator[]))
|
||||
.Method("Component", CombineOverloads(MakeOverload(double& (FVector2D::*) (int32), &FVector2D::Component),
|
||||
MakeOverload(double (FVector2D::*)(int32) const, &FVector2D::Component)))
|
||||
#else
|
||||
.Method("op_Addition",
|
||||
CombineOverloads(MakeOverload(FVector2D(FVector2D::*)(const FVector2D&) const, &FVector2D::operator+),
|
||||
MakeOverload(FVector2D(FVector2D::*)(float) const, &FVector2D::operator+)))
|
||||
.Method("op_Subtraction",
|
||||
CombineOverloads(MakeOverload(FVector2D(FVector2D::*)(const FVector2D&) const, &FVector2D::operator-),
|
||||
MakeOverload(FVector2D(FVector2D::*)(float) const, &FVector2D::operator-)))
|
||||
.Method("op_Multiply", CombineOverloads(MakeOverload(FVector2D(FVector2D::*)(float) const, &FVector2D::operator*),
|
||||
MakeOverload(FVector2D(FVector2D::*)(const FVector2D&) const, &FVector2D::operator*)))
|
||||
.Method("op_Division", CombineOverloads(MakeOverload(FVector2D(FVector2D::*)(float) const, &FVector2D::operator/),
|
||||
MakeOverload(FVector2D(FVector2D::*)(const FVector2D&) const, &FVector2D::operator/)))
|
||||
.Method("set_Item", SelectFunction(float& (FVector2D::*) (int32), &FVector2D::operator[]))
|
||||
.Method("get_Item", SelectFunction(float (FVector2D::*)(int32) const, &FVector2D::operator[]))
|
||||
.Method("Component", CombineOverloads(MakeOverload(float& (FVector2D::*) (int32), &FVector2D::Component),
|
||||
MakeOverload(float (FVector2D::*)(int32) const, &FVector2D::Component)))
|
||||
#endif
|
||||
.Function("DotProduct", MakeFunction(&FVector2D::DotProduct))
|
||||
.Function("DistSquared", MakeFunction(&FVector2D::DistSquared))
|
||||
.Function("Distance", MakeFunction(&FVector2D::Distance))
|
||||
.Function("CrossProduct", MakeFunction(&FVector2D::CrossProduct))
|
||||
.Method("Equals", MakeFunction(&FVector2D::Equals, KINDA_SMALL_NUMBER))
|
||||
.Method("Set", MakeFunction(&FVector2D::Set))
|
||||
.Method("GetMax", MakeFunction(&FVector2D::GetMax))
|
||||
.Method("GetAbsMax", MakeFunction(&FVector2D::GetAbsMax))
|
||||
.Method("GetMin", MakeFunction(&FVector2D::GetMin))
|
||||
.Method("Size", MakeFunction(&FVector2D::Size))
|
||||
.Method("SizeSquared", MakeFunction(&FVector2D::SizeSquared))
|
||||
.Method("GetRotated", MakeFunction(&FVector2D::GetRotated))
|
||||
.Method("GetSafeNormal", MakeFunction(&FVector2D::GetSafeNormal, SMALL_NUMBER))
|
||||
.Method("Normalize", MakeFunction(&FVector2D::Normalize, SMALL_NUMBER))
|
||||
.Method("IsNearlyZero", MakeFunction(&FVector2D::IsNearlyZero, KINDA_SMALL_NUMBER))
|
||||
.Method("ToDirectionAndLength",
|
||||
SelectFunction(void (FVector2D::*)(FVector2D&, float&) const, &FVector2D::ToDirectionAndLength))
|
||||
.Method("IsZero", MakeFunction(&FVector2D::IsZero))
|
||||
.Method("IntPoint", MakeFunction(&FVector2D::IntPoint))
|
||||
.Method("RoundToVector", MakeFunction(&FVector2D::RoundToVector))
|
||||
.Method("ClampAxes", MakeFunction(&FVector2D::ClampAxes))
|
||||
.Method("GetSignVector", MakeFunction(&FVector2D::GetSignVector))
|
||||
.Method("GetAbs", MakeFunction(&FVector2D::GetAbs))
|
||||
.Method("ToString", MakeFunction(&FVector2D::ToString))
|
||||
.Method("InitFromString", MakeFunction(&FVector2D::InitFromString))
|
||||
.Method("DiagnosticCheckNaN", MakeFunction(&FVector2D::DiagnosticCheckNaN))
|
||||
.Method("ContainsNaN", MakeFunction(&FVector2D::ContainsNaN))
|
||||
.Method("SphericalToUnitCartesian", MakeFunction(&FVector2D::SphericalToUnitCartesian))
|
||||
.Variable("ZeroVector", MakeReadonlyVariable(&FVector2D::ZeroVector))
|
||||
.Variable("UnitVector", MakeReadonlyVariable(&FVector2D::UnitVector))
|
||||
.Variable("Unit45Deg", MakeReadonlyVariable(&FVector2D::Unit45Deg))
|
||||
.Register();
|
||||
}
|
||||
};
|
||||
|
||||
AutoRegisterForFVector2D _AutoRegisterForFVector2D_;
|
||||
@@ -0,0 +1,71 @@
|
||||
/*
|
||||
* Tencent is pleased to support the open source community by making Puerts available.
|
||||
* Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
|
||||
* Puerts is licensed under the BSD 3-Clause License, except for the third-party components listed in the file 'LICENSE' which may
|
||||
* be subject to their corresponding license terms. This file is subject to the terms and conditions defined in file 'LICENSE',
|
||||
* which is part of this source code package.
|
||||
*/
|
||||
|
||||
// gen by puerts gen tools
|
||||
|
||||
#include "CoreMinimal.h"
|
||||
#include "UsingTypeDecl.hpp"
|
||||
|
||||
struct AutoRegisterForFVector4
|
||||
{
|
||||
AutoRegisterForFVector4()
|
||||
{
|
||||
puerts::DefineClass<FVector4>()
|
||||
.Constructor(CombineConstructors(MakeConstructor(FVector4, const FVector&, float),
|
||||
MakeConstructor(FVector4, const FLinearColor&), MakeConstructor(FVector4, float, float, float, float),
|
||||
MakeConstructor(FVector4, FVector2D, FVector2D), MakeConstructor(FVector4, const FIntVector4&),
|
||||
MakeConstructor(FVector4, EForceInit)))
|
||||
.Property("X", MakeProperty(&FVector4::X))
|
||||
.Property("Y", MakeProperty(&FVector4::Y))
|
||||
.Property("Z", MakeProperty(&FVector4::Z))
|
||||
.Property("W", MakeProperty(&FVector4::W))
|
||||
.Method("op_UnaryNegation", SelectFunction(FVector4(FVector4::*)() const, &FVector4::operator-))
|
||||
.Method("op_Addition", MakeFunction(&FVector4::operator+))
|
||||
.Method("op_Subtraction", SelectFunction(FVector4(FVector4::*)(const FVector4&) const, &FVector4::operator-))
|
||||
.Method("op_Multiply", CombineOverloads(MakeOverload(FVector4(FVector4::*)(float) const, &FVector4::operator*),
|
||||
MakeOverload(FVector4(FVector4::*)(const FVector4&) const, &FVector4::operator*)))
|
||||
.Method("op_Division", CombineOverloads(MakeOverload(FVector4(FVector4::*)(float) const, &FVector4::operator/),
|
||||
MakeOverload(FVector4(FVector4::*)(const FVector4&) const, &FVector4::operator/)))
|
||||
.Method("op_Equality", MakeFunction(&FVector4::operator==))
|
||||
.Method("op_Inequality", MakeFunction(&FVector4::operator!=))
|
||||
.Method("op_ExclusiveOr", MakeFunction(&FVector4::operator^))
|
||||
#if ENGINE_MAJOR_VERSION >= 5 && ENGINE_MINOR_VERSION > 2
|
||||
.Method("set_Item", SelectFunction(double& (FVector4::*) (int32), &FVector4::operator[]))
|
||||
.Method("get_Item", SelectFunction(double (FVector4::*)(int32) const, &FVector4::operator[]))
|
||||
.Method("Component", CombineOverloads(MakeOverload(double& (FVector4::*) (int32), &FVector4::Component),
|
||||
MakeOverload(const double& (FVector4::*) (int32) const, &FVector4::Component)))
|
||||
#else
|
||||
.Method("set_Item", SelectFunction(float& (FVector4::*) (int32), &FVector4::operator[]))
|
||||
.Method("get_Item", SelectFunction(float (FVector4::*)(int32) const, &FVector4::operator[]))
|
||||
.Method("Component", CombineOverloads(MakeOverload(float& (FVector4::*) (int32), &FVector4::Component),
|
||||
MakeOverload(const float& (FVector4::*) (int32) const, &FVector4::Component)))
|
||||
#endif
|
||||
.Method("Equals", MakeFunction(&FVector4::Equals, KINDA_SMALL_NUMBER))
|
||||
.Method("IsUnit3", MakeFunction(&FVector4::IsUnit3, KINDA_SMALL_NUMBER))
|
||||
.Method("ToString", MakeFunction(&FVector4::ToString))
|
||||
.Method("InitFromString", MakeFunction(&FVector4::InitFromString))
|
||||
.Method("GetSafeNormal", MakeFunction(&FVector4::GetSafeNormal, SMALL_NUMBER))
|
||||
.Method("GetUnsafeNormal3", MakeFunction(&FVector4::GetUnsafeNormal3))
|
||||
.Method("ToOrientationRotator", MakeFunction(&FVector4::ToOrientationRotator))
|
||||
.Method("ToOrientationQuat", MakeFunction(&FVector4::ToOrientationQuat))
|
||||
.Method("Rotation", MakeFunction(&FVector4::Rotation))
|
||||
.Method("Set", MakeFunction(&FVector4::Set))
|
||||
.Method("Size3", MakeFunction(&FVector4::Size3))
|
||||
.Method("SizeSquared3", MakeFunction(&FVector4::SizeSquared3))
|
||||
.Method("Size", MakeFunction(&FVector4::Size))
|
||||
.Method("SizeSquared", MakeFunction(&FVector4::SizeSquared))
|
||||
.Method("ContainsNaN", MakeFunction(&FVector4::ContainsNaN))
|
||||
.Method("IsNearlyZero3", MakeFunction(&FVector4::IsNearlyZero3, KINDA_SMALL_NUMBER))
|
||||
.Method("Reflect3", MakeFunction(&FVector4::Reflect3))
|
||||
.Method("FindBestAxisVectors3", MakeFunction(&FVector4::FindBestAxisVectors3))
|
||||
.Method("DiagnosticCheckNaN", MakeFunction(&FVector4::DiagnosticCheckNaN))
|
||||
.Register();
|
||||
}
|
||||
};
|
||||
|
||||
AutoRegisterForFVector4 _AutoRegisterForFVector4_;
|
||||
@@ -0,0 +1,154 @@
|
||||
/*
|
||||
* Tencent is pleased to support the open source community by making Puerts available.
|
||||
* Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
|
||||
* Puerts is licensed under the BSD 3-Clause License, except for the third-party components listed in the file 'LICENSE' which may
|
||||
* be subject to their corresponding license terms. This file is subject to the terms and conditions defined in file 'LICENSE',
|
||||
* which is part of this source code package.
|
||||
*/
|
||||
|
||||
// gen by puerts gen tools
|
||||
|
||||
#include "CoreMinimal.h"
|
||||
#include "UsingTypeDecl.hpp"
|
||||
|
||||
struct AutoRegisterForFVector
|
||||
{
|
||||
AutoRegisterForFVector()
|
||||
{
|
||||
puerts::DefineClass<FVector>()
|
||||
.Constructor(CombineConstructors(MakeConstructor(FVector), MakeConstructor(FVector, float),
|
||||
MakeConstructor(FVector, float, float, float), MakeConstructor(FVector, const FVector2D, float),
|
||||
MakeConstructor(FVector, const FVector4&), MakeConstructor(FVector, const FLinearColor&),
|
||||
MakeConstructor(FVector, FIntVector), MakeConstructor(FVector, FIntPoint), MakeConstructor(FVector, EForceInit)))
|
||||
.Property("X", MakeProperty(&FVector::X))
|
||||
.Property("Y", MakeProperty(&FVector::Y))
|
||||
.Property("Z", MakeProperty(&FVector::Z))
|
||||
.Method("DiagnosticCheckNaN", CombineOverloads(MakeOverload(void (FVector::*)() const, &FVector::DiagnosticCheckNaN),
|
||||
MakeOverload(void (FVector::*)(const TCHAR*) const, &FVector::DiagnosticCheckNaN)))
|
||||
.Method("op_ExclusiveOr", MakeFunction(&FVector::operator^))
|
||||
.Function("CrossProduct", MakeFunction(&FVector::CrossProduct))
|
||||
.Method("op_BitwiseOr", MakeFunction(&FVector::operator|))
|
||||
.Function("DotProduct", MakeFunction(&FVector::DotProduct))
|
||||
.Method("op_Addition", CombineOverloads(MakeOverload(FVector(FVector::*)(const FVector&) const, &FVector::operator+),
|
||||
MakeOverload(FVector(FVector::*)(float) const, &FVector::operator+)))
|
||||
.Method("op_Subtraction", CombineOverloads(MakeOverload(FVector(FVector::*)(const FVector&) const, &FVector::operator-),
|
||||
MakeOverload(FVector(FVector::*)(float) const, &FVector::operator-)))
|
||||
.Method("op_Multiply", CombineOverloads(MakeOverload(FVector(FVector::*)(float) const, &FVector::operator*),
|
||||
MakeOverload(FVector(FVector::*)(const FVector&) const, &FVector::operator*)))
|
||||
.Method("op_Division", CombineOverloads(MakeOverload(FVector(FVector::*)(float) const, &FVector::operator/),
|
||||
MakeOverload(FVector(FVector::*)(const FVector&) const, &FVector::operator/)))
|
||||
.Method("op_Equality", MakeFunction(&FVector::operator==))
|
||||
.Method("op_Inequality", MakeFunction(&FVector::operator!=))
|
||||
.Method("Equals", MakeFunction(&FVector::Equals, KINDA_SMALL_NUMBER))
|
||||
.Method("AllComponentsEqual", MakeFunction(&FVector::AllComponentsEqual))
|
||||
.Method("op_UnaryNegation", SelectFunction(FVector(FVector::*)() const, &FVector::operator-))
|
||||
#if ENGINE_MAJOR_VERSION >= 5 && ENGINE_MINOR_VERSION > 2
|
||||
.Method("set_Item", SelectFunction(double& (FVector::*) (int32), &FVector::operator[]))
|
||||
.Method("get_Item", SelectFunction(double (FVector::*)(int32) const, &FVector::operator[]))
|
||||
.Method("Component", CombineOverloads(MakeOverload(double& (FVector::*) (int32), &FVector::Component),
|
||||
MakeOverload(double (FVector::*)(int32) const, &FVector::Component)))
|
||||
#else
|
||||
.Method("set_Item", SelectFunction(float& (FVector::*) (int32), &FVector::operator[]))
|
||||
.Method("get_Item", SelectFunction(float (FVector::*)(int32) const, &FVector::operator[]))
|
||||
.Method("Component", CombineOverloads(MakeOverload(float& (FVector::*) (int32), &FVector::Component),
|
||||
MakeOverload(float (FVector::*)(int32) const, &FVector::Component)))
|
||||
#endif
|
||||
.Method("GetComponentForAxis", MakeFunction(&FVector::GetComponentForAxis))
|
||||
.Method("SetComponentForAxis", MakeFunction(&FVector::SetComponentForAxis))
|
||||
.Method("Set", MakeFunction(&FVector::Set))
|
||||
.Method("GetMax", MakeFunction(&FVector::GetMax))
|
||||
.Method("GetAbsMax", MakeFunction(&FVector::GetAbsMax))
|
||||
.Method("GetMin", MakeFunction(&FVector::GetMin))
|
||||
.Method("GetAbsMin", MakeFunction(&FVector::GetAbsMin))
|
||||
.Method("ComponentMin", MakeFunction(&FVector::ComponentMin))
|
||||
.Method("ComponentMax", MakeFunction(&FVector::ComponentMax))
|
||||
.Method("GetAbs", MakeFunction(&FVector::GetAbs))
|
||||
.Method("Size", MakeFunction(&FVector::Size))
|
||||
.Method("SizeSquared", MakeFunction(&FVector::SizeSquared))
|
||||
.Method("Size2D", MakeFunction(&FVector::Size2D))
|
||||
.Method("SizeSquared2D", MakeFunction(&FVector::SizeSquared2D))
|
||||
.Method("IsNearlyZero", MakeFunction(&FVector::IsNearlyZero, KINDA_SMALL_NUMBER))
|
||||
.Method("IsZero", MakeFunction(&FVector::IsZero))
|
||||
.Method("IsUnit", MakeFunction(&FVector::IsUnit, KINDA_SMALL_NUMBER))
|
||||
.Method("IsNormalized", MakeFunction(&FVector::IsNormalized))
|
||||
.Method("Normalize", MakeFunction(&FVector::Normalize, SMALL_NUMBER))
|
||||
.Method("GetUnsafeNormal", MakeFunction(&FVector::GetUnsafeNormal))
|
||||
#if ENGINE_MAJOR_VERSION >= 5 && ENGINE_MINOR_VERSION >= 3
|
||||
.Method("GetSafeNormal", MakeFunction(&FVector::GetSafeNormal, SMALL_NUMBER, FVector::ZeroVector))
|
||||
.Method("GetSafeNormal2D", MakeFunction(&FVector::GetSafeNormal2D, SMALL_NUMBER, FVector::ZeroVector))
|
||||
#else
|
||||
.Method("GetSafeNormal", MakeFunction(&FVector::GetSafeNormal, SMALL_NUMBER))
|
||||
.Method("GetSafeNormal2D", MakeFunction(&FVector::GetSafeNormal2D, SMALL_NUMBER))
|
||||
#endif
|
||||
.Method(
|
||||
"ToDirectionAndLength", SelectFunction(void (FVector::*)(FVector&, float&) const, &FVector::ToDirectionAndLength))
|
||||
.Method("GetSignVector", MakeFunction(&FVector::GetSignVector))
|
||||
.Method("Projection", MakeFunction(&FVector::Projection))
|
||||
.Method("GetUnsafeNormal2D", MakeFunction(&FVector::GetUnsafeNormal2D))
|
||||
.Method("GridSnap", MakeFunction(&FVector::GridSnap))
|
||||
.Method("BoundToCube", MakeFunction(&FVector::BoundToCube))
|
||||
.Method("BoundToBox", MakeFunction(&FVector::BoundToBox))
|
||||
.Method("GetClampedToSize", MakeFunction(&FVector::GetClampedToSize))
|
||||
.Method("GetClampedToSize2D", MakeFunction(&FVector::GetClampedToSize2D))
|
||||
.Method("GetClampedToMaxSize", MakeFunction(&FVector::GetClampedToMaxSize))
|
||||
.Method("GetClampedToMaxSize2D", MakeFunction(&FVector::GetClampedToMaxSize2D))
|
||||
.Method("AddBounded", MakeFunction(&FVector::AddBounded))
|
||||
.Method("Reciprocal", MakeFunction(&FVector::Reciprocal))
|
||||
.Method("IsUniform", MakeFunction(&FVector::IsUniform, KINDA_SMALL_NUMBER))
|
||||
.Method("MirrorByVector", MakeFunction(&FVector::MirrorByVector))
|
||||
.Method("MirrorByPlane", MakeFunction(&FVector::MirrorByPlane))
|
||||
.Method("RotateAngleAxis", MakeFunction(&FVector::RotateAngleAxis))
|
||||
.Method("CosineAngle2D", MakeFunction(&FVector::CosineAngle2D))
|
||||
.Method("ProjectOnTo", MakeFunction(&FVector::ProjectOnTo))
|
||||
.Method("ProjectOnToNormal", MakeFunction(&FVector::ProjectOnToNormal))
|
||||
.Method("ToOrientationRotator", MakeFunction(&FVector::ToOrientationRotator))
|
||||
.Method("ToOrientationQuat", MakeFunction(&FVector::ToOrientationQuat))
|
||||
.Method("Rotation", MakeFunction(&FVector::Rotation))
|
||||
.Method("FindBestAxisVectors", MakeFunction(&FVector::FindBestAxisVectors))
|
||||
.Method("UnwindEuler", MakeFunction(&FVector::UnwindEuler))
|
||||
.Method("ContainsNaN", MakeFunction(&FVector::ContainsNaN))
|
||||
.Method("ToString", MakeFunction(&FVector::ToString))
|
||||
.Method("ToText", MakeFunction(&FVector::ToText))
|
||||
.Method("ToCompactString", MakeFunction(&FVector::ToCompactString))
|
||||
.Method("ToCompactText", MakeFunction(&FVector::ToCompactText))
|
||||
.Method("InitFromString", MakeFunction(&FVector::InitFromString))
|
||||
.Method("UnitCartesianToSpherical", MakeFunction(&FVector::UnitCartesianToSpherical))
|
||||
.Method("HeadingAngle", MakeFunction(&FVector::HeadingAngle))
|
||||
.Function("CreateOrthonormalBasis", MakeFunction(&FVector::CreateOrthonormalBasis))
|
||||
.Function("PointsAreSame", MakeFunction(&FVector::PointsAreSame))
|
||||
.Function("PointsAreNear", MakeFunction(&FVector::PointsAreNear))
|
||||
.Function("PointPlaneDist", MakeFunction(&FVector::PointPlaneDist))
|
||||
.Function("PointPlaneProject",
|
||||
CombineOverloads(MakeOverload(FVector(*)(const FVector&, const FPlane&), &FVector::PointPlaneProject),
|
||||
MakeOverload(
|
||||
FVector(*)(const FVector&, const FVector&, const FVector&, const FVector&), &FVector::PointPlaneProject),
|
||||
MakeOverload(FVector(*)(const FVector&, const FVector&, const FVector&), &FVector::PointPlaneProject)))
|
||||
.Function("VectorPlaneProject", MakeFunction(&FVector::VectorPlaneProject))
|
||||
.Function("Dist", MakeFunction(&FVector::Dist))
|
||||
.Function("Distance", MakeFunction(&FVector::Distance))
|
||||
.Function("DistXY", MakeFunction(&FVector::DistXY))
|
||||
.Function("Dist2D", MakeFunction(&FVector::Dist2D))
|
||||
.Function("DistSquared", MakeFunction(&FVector::DistSquared))
|
||||
.Function("DistSquaredXY", MakeFunction(&FVector::DistSquaredXY))
|
||||
.Function("DistSquared2D", MakeFunction(&FVector::DistSquared2D))
|
||||
.Function("BoxPushOut", MakeFunction(&FVector::BoxPushOut))
|
||||
.Function("Parallel", MakeFunction(&FVector::Parallel, THRESH_NORMALS_ARE_PARALLEL))
|
||||
.Function("Coincident", MakeFunction(&FVector::Coincident, THRESH_NORMALS_ARE_PARALLEL))
|
||||
.Function("Orthogonal", MakeFunction(&FVector::Orthogonal, THRESH_NORMALS_ARE_ORTHOGONAL))
|
||||
.Function("Coplanar", MakeFunction(&FVector::Coplanar, THRESH_NORMALS_ARE_PARALLEL))
|
||||
.Function("Triple", MakeFunction(&FVector::Triple))
|
||||
.Function("RadiansToDegrees", MakeFunction(&FVector::RadiansToDegrees))
|
||||
.Function("DegreesToRadians", MakeFunction(&FVector::DegreesToRadians))
|
||||
.Variable("ZeroVector", MakeReadonlyVariable(&FVector::ZeroVector))
|
||||
.Variable("OneVector", MakeReadonlyVariable(&FVector::OneVector))
|
||||
.Variable("UpVector", MakeReadonlyVariable(&FVector::UpVector))
|
||||
.Variable("DownVector", MakeReadonlyVariable(&FVector::DownVector))
|
||||
.Variable("ForwardVector", MakeReadonlyVariable(&FVector::ForwardVector))
|
||||
.Variable("BackwardVector", MakeReadonlyVariable(&FVector::BackwardVector))
|
||||
.Variable("RightVector", MakeReadonlyVariable(&FVector::RightVector))
|
||||
.Variable("LeftVector", MakeReadonlyVariable(&FVector::LeftVector))
|
||||
.Register();
|
||||
}
|
||||
};
|
||||
|
||||
AutoRegisterForFVector _AutoRegisterForFVector_;
|
||||
@@ -0,0 +1,31 @@
|
||||
/*
|
||||
* Tencent is pleased to support the open source community by making Puerts available.
|
||||
* Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
|
||||
* Puerts is licensed under the BSD 3-Clause License, except for the third-party components listed in the file 'LICENSE' which may
|
||||
* be subject to their corresponding license terms. This file is subject to the terms and conditions defined in file 'LICENSE',
|
||||
* which is part of this source code package.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#include "CoreMinimal.h"
|
||||
#include "Binding.hpp"
|
||||
#include "UEDataBinding.hpp"
|
||||
|
||||
UsingUStruct(FBox2D);
|
||||
UsingUStruct(FVector2D);
|
||||
UsingUStruct(FLinearColor);
|
||||
UsingUStruct(FColor);
|
||||
UsingUStruct(FVector);
|
||||
UsingUStruct(FGuid);
|
||||
UsingUStruct(FIntPoint);
|
||||
UsingUStruct(FIntVector);
|
||||
UsingUStruct(FQuat);
|
||||
UsingUStruct(FRotator);
|
||||
UsingUStruct(FTransform);
|
||||
UsingUStruct(FVector4);
|
||||
UsingUStruct(FPlane);
|
||||
UsingCppType(FFloat16Color);
|
||||
UsingUStruct(FMatrix);
|
||||
UsingContainer(TArray<FVector2D>);
|
||||
UsingUStruct(FIntVector4);
|
||||
Reference in New Issue
Block a user