1853 lines
74 KiB
C++
1853 lines
74 KiB
C++
/*
|
|
* 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 "GenHeaders.h"
|
|
#include "CoreMinimal.h"
|
|
#include "DataTransfer.h"
|
|
#include "JSClassRegister.h"
|
|
|
|
// <SourceLocation file 'D:\\Program Files\\Epic Games\\UE_4.24\\Engine\\Source\\Runtime\\Core\\Public\\Math/Quat.h', line 120,
|
|
// column 20> unsupported method : operator+= FQuat (const FQuat &) __attribute__((thiscall))
|
|
|
|
// <SourceLocation file 'D:\\Program Files\\Epic Games\\UE_4.24\\Engine\\Source\\Runtime\\Core\\Public\\Math/Quat.h', line 156,
|
|
// column 20> unsupported method : operator-= FQuat (const FQuat &) __attribute__((thiscall))
|
|
|
|
// <SourceLocation file 'D:\\Program Files\\Epic Games\\UE_4.24\\Engine\\Source\\Runtime\\Core\\Public\\Math/Quat.h', line 178,
|
|
// column 20> unsupported method : operator*= FQuat (const FQuat &) __attribute__((thiscall))
|
|
|
|
// <SourceLocation file 'D:\\Program Files\\Epic Games\\UE_4.24\\Engine\\Source\\Runtime\\Core\\Public\\Math/Quat.h', line 198,
|
|
// column 10> unsupported method : op_Multiply FMatrix (const FMatrix &) __attribute__((thiscall)) const
|
|
|
|
// <SourceLocation file 'D:\\Program Files\\Epic Games\\UE_4.24\\Engine\\Source\\Runtime\\Core\\Public\\Math/Quat.h', line 206,
|
|
// column 20> unsupported method : operator*= FQuat (const float) __attribute__((thiscall))
|
|
|
|
// <SourceLocation file 'D:\\Program Files\\Epic Games\\UE_4.24\\Engine\\Source\\Runtime\\Core\\Public\\Math/Quat.h', line 222,
|
|
// column 20> unsupported method : operator/= FQuat (const float) __attribute__((thiscall))
|
|
|
|
static void* _FQuatNew_(const v8::FunctionCallbackInfo<v8::Value>& Info)
|
|
{
|
|
v8::Isolate* Isolate = Info.GetIsolate();
|
|
v8::Local<v8::Context> Context = Isolate->GetCurrentContext();
|
|
if (Info.Length() == 0)
|
|
{
|
|
if (true)
|
|
{
|
|
FQuat* Obj = new FQuat();
|
|
|
|
// UE_LOG(LogTemp, Warning, TEXT("_FQuatNew_:%p"), Obj);
|
|
return Obj;
|
|
}
|
|
}
|
|
if (Info.Length() == 1)
|
|
{
|
|
if (Info[0]->IsNumber())
|
|
{
|
|
EForceInit Arg0 = EForceInit(Info[0]->ToInt32(Context).ToLocalChecked()->Value());
|
|
FQuat* Obj = new FQuat(Arg0);
|
|
|
|
// UE_LOG(LogTemp, Warning, TEXT("_FQuatNew_:%p"), Obj);
|
|
return Obj;
|
|
}
|
|
}
|
|
if (Info.Length() == 4)
|
|
{
|
|
if (Info[0]->IsNumber() && Info[1]->IsNumber() && Info[2]->IsNumber() && Info[3]->IsNumber())
|
|
{
|
|
float Arg0 = Info[0]->ToNumber(Context).ToLocalChecked()->Value();
|
|
float Arg1 = Info[1]->ToNumber(Context).ToLocalChecked()->Value();
|
|
float Arg2 = Info[2]->ToNumber(Context).ToLocalChecked()->Value();
|
|
float Arg3 = Info[3]->ToNumber(Context).ToLocalChecked()->Value();
|
|
FQuat* Obj = new FQuat(Arg0, Arg1, Arg2, Arg3);
|
|
|
|
// UE_LOG(LogTemp, Warning, TEXT("_FQuatNew_:%p"), Obj);
|
|
return Obj;
|
|
}
|
|
}
|
|
if (Info.Length() == 1)
|
|
{
|
|
if (Info[0]->IsObject() &&
|
|
|
|
PUERTS_NAMESPACE::DataTransfer::IsInstanceOf<FRotator>(Isolate, Info[0]->ToObject(Context).ToLocalChecked()))
|
|
{
|
|
const FRotator* Arg0 =
|
|
PUERTS_NAMESPACE::DataTransfer::GetPointerFast<FRotator>(Info[0]->ToObject(Context).ToLocalChecked());
|
|
FQuat* Obj = new FQuat(*Arg0);
|
|
|
|
// UE_LOG(LogTemp, Warning, TEXT("_FQuatNew_:%p"), Obj);
|
|
return Obj;
|
|
}
|
|
}
|
|
if (Info.Length() == 2)
|
|
{
|
|
if (Info[0]->IsObject() &&
|
|
|
|
PUERTS_NAMESPACE::DataTransfer::IsInstanceOf<FVector>(Isolate, Info[0]->ToObject(Context).ToLocalChecked()) &&
|
|
Info[1]->IsNumber())
|
|
{
|
|
FVector* Arg0 = PUERTS_NAMESPACE::DataTransfer::GetPointerFast<FVector>(Info[0]->ToObject(Context).ToLocalChecked());
|
|
float Arg1 = Info[1]->ToNumber(Context).ToLocalChecked()->Value();
|
|
FQuat* Obj = new FQuat(*Arg0, Arg1);
|
|
|
|
// UE_LOG(LogTemp, Warning, TEXT("_FQuatNew_:%p"), Obj);
|
|
return Obj;
|
|
}
|
|
}
|
|
PUERTS_NAMESPACE::DataTransfer::ThrowException(Isolate, "Invalid argument!");
|
|
return nullptr;
|
|
}
|
|
|
|
static void _FQuatDelete_(void* Ptr, void* ClassData, void* EnvData)
|
|
{
|
|
FQuat* Self = static_cast<FQuat*>(Ptr);
|
|
// UE_LOG(LogTemp, Warning, TEXT("_FQuatDelete_:%p"), Self);
|
|
delete Self;
|
|
}
|
|
static void FQuatM_op_Addition(const v8::FunctionCallbackInfo<v8::Value>& Info)
|
|
{
|
|
v8::Isolate* Isolate = Info.GetIsolate();
|
|
v8::Local<v8::Context> Context = Isolate->GetCurrentContext();
|
|
if (Info.Length() == 1)
|
|
{
|
|
if (Info[0]->IsObject() &&
|
|
|
|
PUERTS_NAMESPACE::DataTransfer::IsInstanceOf<FQuat>(Isolate, Info[0]->ToObject(Context).ToLocalChecked()))
|
|
{
|
|
const FQuat* Arg0 = PUERTS_NAMESPACE::DataTransfer::GetPointerFast<FQuat>(Info[0]->ToObject(Context).ToLocalChecked());
|
|
auto Self = PUERTS_NAMESPACE::DataTransfer::GetPointerFast<FQuat>(Info.Holder());
|
|
if (!Self)
|
|
{
|
|
PUERTS_NAMESPACE::DataTransfer::ThrowException(
|
|
Isolate, "[FQuat::M_op_Addition] Attempt to access a NULL self pointer");
|
|
return;
|
|
}
|
|
auto MethodResult = Self->operator+(*Arg0);
|
|
void* Ptr = new FQuat(MethodResult);
|
|
|
|
auto V8Result = PUERTS_NAMESPACE::DataTransfer::FindOrAddStruct<FQuat>(Isolate, Context, Ptr, false);
|
|
|
|
Info.GetReturnValue().Set(V8Result);
|
|
|
|
return;
|
|
}
|
|
}
|
|
PUERTS_NAMESPACE::DataTransfer::ThrowException(Isolate, "Invalid argument!");
|
|
}
|
|
|
|
static void FQuatM_op_Subtraction(const v8::FunctionCallbackInfo<v8::Value>& Info)
|
|
{
|
|
v8::Isolate* Isolate = Info.GetIsolate();
|
|
v8::Local<v8::Context> Context = Isolate->GetCurrentContext();
|
|
if (Info.Length() == 1)
|
|
{
|
|
if (Info[0]->IsObject() &&
|
|
|
|
PUERTS_NAMESPACE::DataTransfer::IsInstanceOf<FQuat>(Isolate, Info[0]->ToObject(Context).ToLocalChecked()))
|
|
{
|
|
const FQuat* Arg0 = PUERTS_NAMESPACE::DataTransfer::GetPointerFast<FQuat>(Info[0]->ToObject(Context).ToLocalChecked());
|
|
auto Self = PUERTS_NAMESPACE::DataTransfer::GetPointerFast<FQuat>(Info.Holder());
|
|
if (!Self)
|
|
{
|
|
PUERTS_NAMESPACE::DataTransfer::ThrowException(
|
|
Isolate, "[FQuat::M_op_Subtraction] Attempt to access a NULL self pointer");
|
|
return;
|
|
}
|
|
auto MethodResult = Self->operator-(*Arg0);
|
|
void* Ptr = new FQuat(MethodResult);
|
|
|
|
auto V8Result = PUERTS_NAMESPACE::DataTransfer::FindOrAddStruct<FQuat>(Isolate, Context, Ptr, false);
|
|
|
|
Info.GetReturnValue().Set(V8Result);
|
|
|
|
return;
|
|
}
|
|
}
|
|
PUERTS_NAMESPACE::DataTransfer::ThrowException(Isolate, "Invalid argument!");
|
|
}
|
|
|
|
static void FQuatM_Equals(const v8::FunctionCallbackInfo<v8::Value>& Info)
|
|
{
|
|
v8::Isolate* Isolate = Info.GetIsolate();
|
|
v8::Local<v8::Context> Context = Isolate->GetCurrentContext();
|
|
if (Info.Length() == 2)
|
|
{
|
|
if (Info[0]->IsObject() &&
|
|
|
|
PUERTS_NAMESPACE::DataTransfer::IsInstanceOf<FQuat>(Isolate, Info[0]->ToObject(Context).ToLocalChecked()) &&
|
|
Info[1]->IsNumber())
|
|
{
|
|
const FQuat* Arg0 = PUERTS_NAMESPACE::DataTransfer::GetPointerFast<FQuat>(Info[0]->ToObject(Context).ToLocalChecked());
|
|
float Arg1 = Info[1]->ToNumber(Context).ToLocalChecked()->Value();
|
|
auto Self = PUERTS_NAMESPACE::DataTransfer::GetPointerFast<FQuat>(Info.Holder());
|
|
if (!Self)
|
|
{
|
|
PUERTS_NAMESPACE::DataTransfer::ThrowException(Isolate, "[FQuat::M_Equals] Attempt to access a NULL self pointer");
|
|
return;
|
|
}
|
|
auto MethodResult = Self->Equals(*Arg0, Arg1);
|
|
auto V8Result = v8::Boolean::New(Isolate, MethodResult);
|
|
Info.GetReturnValue().Set(V8Result);
|
|
|
|
return;
|
|
}
|
|
}
|
|
PUERTS_NAMESPACE::DataTransfer::ThrowException(Isolate, "Invalid argument!");
|
|
}
|
|
|
|
static void FQuatM_IsIdentity(const v8::FunctionCallbackInfo<v8::Value>& Info)
|
|
{
|
|
v8::Isolate* Isolate = Info.GetIsolate();
|
|
v8::Local<v8::Context> Context = Isolate->GetCurrentContext();
|
|
if (Info.Length() == 1)
|
|
{
|
|
if (Info[0]->IsNumber())
|
|
{
|
|
float Arg0 = Info[0]->ToNumber(Context).ToLocalChecked()->Value();
|
|
auto Self = PUERTS_NAMESPACE::DataTransfer::GetPointerFast<FQuat>(Info.Holder());
|
|
if (!Self)
|
|
{
|
|
PUERTS_NAMESPACE::DataTransfer::ThrowException(
|
|
Isolate, "[FQuat::M_IsIdentity] Attempt to access a NULL self pointer");
|
|
return;
|
|
}
|
|
auto MethodResult = Self->IsIdentity(Arg0);
|
|
auto V8Result = v8::Boolean::New(Isolate, MethodResult);
|
|
Info.GetReturnValue().Set(V8Result);
|
|
|
|
return;
|
|
}
|
|
}
|
|
PUERTS_NAMESPACE::DataTransfer::ThrowException(Isolate, "Invalid argument!");
|
|
}
|
|
|
|
static void FQuatM_op_Multiply(const v8::FunctionCallbackInfo<v8::Value>& Info)
|
|
{
|
|
v8::Isolate* Isolate = Info.GetIsolate();
|
|
v8::Local<v8::Context> Context = Isolate->GetCurrentContext();
|
|
if (Info.Length() == 1)
|
|
{
|
|
if (Info[0]->IsObject() &&
|
|
|
|
PUERTS_NAMESPACE::DataTransfer::IsInstanceOf<FQuat>(Isolate, Info[0]->ToObject(Context).ToLocalChecked()))
|
|
{
|
|
const FQuat* Arg0 = PUERTS_NAMESPACE::DataTransfer::GetPointerFast<FQuat>(Info[0]->ToObject(Context).ToLocalChecked());
|
|
auto Self = PUERTS_NAMESPACE::DataTransfer::GetPointerFast<FQuat>(Info.Holder());
|
|
if (!Self)
|
|
{
|
|
PUERTS_NAMESPACE::DataTransfer::ThrowException(
|
|
Isolate, "[FQuat::M_op_Multiply] Attempt to access a NULL self pointer");
|
|
return;
|
|
}
|
|
auto MethodResult = Self->operator*(*Arg0);
|
|
void* Ptr = new FQuat(MethodResult);
|
|
|
|
auto V8Result = PUERTS_NAMESPACE::DataTransfer::FindOrAddStruct<FQuat>(Isolate, Context, Ptr, false);
|
|
|
|
Info.GetReturnValue().Set(V8Result);
|
|
|
|
return;
|
|
}
|
|
}
|
|
if (Info.Length() == 1)
|
|
{
|
|
if (Info[0]->IsObject() &&
|
|
|
|
PUERTS_NAMESPACE::DataTransfer::IsInstanceOf<FVector>(Isolate, Info[0]->ToObject(Context).ToLocalChecked()))
|
|
{
|
|
const FVector* Arg0 =
|
|
PUERTS_NAMESPACE::DataTransfer::GetPointerFast<FVector>(Info[0]->ToObject(Context).ToLocalChecked());
|
|
auto Self = PUERTS_NAMESPACE::DataTransfer::GetPointerFast<FQuat>(Info.Holder());
|
|
if (!Self)
|
|
{
|
|
PUERTS_NAMESPACE::DataTransfer::ThrowException(
|
|
Isolate, "[FQuat::M_op_Multiply] Attempt to access a NULL self pointer");
|
|
return;
|
|
}
|
|
auto MethodResult = Self->operator*(*Arg0);
|
|
void* Ptr = new FVector(MethodResult);
|
|
|
|
auto V8Result = PUERTS_NAMESPACE::DataTransfer::FindOrAddStruct<FVector>(Isolate, Context, Ptr, false);
|
|
|
|
Info.GetReturnValue().Set(V8Result);
|
|
|
|
return;
|
|
}
|
|
}
|
|
if (Info.Length() == 1)
|
|
{
|
|
if (Info[0]->IsNumber())
|
|
{
|
|
const float Arg0 = Info[0]->ToNumber(Context).ToLocalChecked()->Value();
|
|
auto Self = PUERTS_NAMESPACE::DataTransfer::GetPointerFast<FQuat>(Info.Holder());
|
|
if (!Self)
|
|
{
|
|
PUERTS_NAMESPACE::DataTransfer::ThrowException(
|
|
Isolate, "[FQuat::M_op_Multiply] Attempt to access a NULL self pointer");
|
|
return;
|
|
}
|
|
auto MethodResult = Self->operator*(Arg0);
|
|
void* Ptr = new FQuat(MethodResult);
|
|
|
|
auto V8Result = PUERTS_NAMESPACE::DataTransfer::FindOrAddStruct<FQuat>(Isolate, Context, Ptr, false);
|
|
|
|
Info.GetReturnValue().Set(V8Result);
|
|
|
|
return;
|
|
}
|
|
}
|
|
PUERTS_NAMESPACE::DataTransfer::ThrowException(Isolate, "Invalid argument!");
|
|
}
|
|
|
|
static void FQuatM_op_Division(const v8::FunctionCallbackInfo<v8::Value>& Info)
|
|
{
|
|
v8::Isolate* Isolate = Info.GetIsolate();
|
|
v8::Local<v8::Context> Context = Isolate->GetCurrentContext();
|
|
if (Info.Length() == 1)
|
|
{
|
|
if (Info[0]->IsNumber())
|
|
{
|
|
const float Arg0 = Info[0]->ToNumber(Context).ToLocalChecked()->Value();
|
|
auto Self = PUERTS_NAMESPACE::DataTransfer::GetPointerFast<FQuat>(Info.Holder());
|
|
if (!Self)
|
|
{
|
|
PUERTS_NAMESPACE::DataTransfer::ThrowException(
|
|
Isolate, "[FQuat::M_op_Division] Attempt to access a NULL self pointer");
|
|
return;
|
|
}
|
|
auto MethodResult = Self->operator/(Arg0);
|
|
void* Ptr = new FQuat(MethodResult);
|
|
|
|
auto V8Result = PUERTS_NAMESPACE::DataTransfer::FindOrAddStruct<FQuat>(Isolate, Context, Ptr, false);
|
|
|
|
Info.GetReturnValue().Set(V8Result);
|
|
|
|
return;
|
|
}
|
|
}
|
|
PUERTS_NAMESPACE::DataTransfer::ThrowException(Isolate, "Invalid argument!");
|
|
}
|
|
|
|
static void FQuatM_op_Equality(const v8::FunctionCallbackInfo<v8::Value>& Info)
|
|
{
|
|
v8::Isolate* Isolate = Info.GetIsolate();
|
|
v8::Local<v8::Context> Context = Isolate->GetCurrentContext();
|
|
if (Info.Length() == 1)
|
|
{
|
|
if (Info[0]->IsObject() &&
|
|
|
|
PUERTS_NAMESPACE::DataTransfer::IsInstanceOf<FQuat>(Isolate, Info[0]->ToObject(Context).ToLocalChecked()))
|
|
{
|
|
const FQuat* Arg0 = PUERTS_NAMESPACE::DataTransfer::GetPointerFast<FQuat>(Info[0]->ToObject(Context).ToLocalChecked());
|
|
auto Self = PUERTS_NAMESPACE::DataTransfer::GetPointerFast<FQuat>(Info.Holder());
|
|
if (!Self)
|
|
{
|
|
PUERTS_NAMESPACE::DataTransfer::ThrowException(
|
|
Isolate, "[FQuat::M_op_Equality] Attempt to access a NULL self pointer");
|
|
return;
|
|
}
|
|
auto MethodResult = Self->operator==(*Arg0);
|
|
auto V8Result = v8::Boolean::New(Isolate, MethodResult);
|
|
Info.GetReturnValue().Set(V8Result);
|
|
|
|
return;
|
|
}
|
|
}
|
|
PUERTS_NAMESPACE::DataTransfer::ThrowException(Isolate, "Invalid argument!");
|
|
}
|
|
|
|
static void FQuatM_op_Inequality(const v8::FunctionCallbackInfo<v8::Value>& Info)
|
|
{
|
|
v8::Isolate* Isolate = Info.GetIsolate();
|
|
v8::Local<v8::Context> Context = Isolate->GetCurrentContext();
|
|
if (Info.Length() == 1)
|
|
{
|
|
if (Info[0]->IsObject() &&
|
|
|
|
PUERTS_NAMESPACE::DataTransfer::IsInstanceOf<FQuat>(Isolate, Info[0]->ToObject(Context).ToLocalChecked()))
|
|
{
|
|
const FQuat* Arg0 = PUERTS_NAMESPACE::DataTransfer::GetPointerFast<FQuat>(Info[0]->ToObject(Context).ToLocalChecked());
|
|
auto Self = PUERTS_NAMESPACE::DataTransfer::GetPointerFast<FQuat>(Info.Holder());
|
|
if (!Self)
|
|
{
|
|
PUERTS_NAMESPACE::DataTransfer::ThrowException(
|
|
Isolate, "[FQuat::M_op_Inequality] Attempt to access a NULL self pointer");
|
|
return;
|
|
}
|
|
auto MethodResult = Self->operator!=(*Arg0);
|
|
auto V8Result = v8::Boolean::New(Isolate, MethodResult);
|
|
Info.GetReturnValue().Set(V8Result);
|
|
|
|
return;
|
|
}
|
|
}
|
|
PUERTS_NAMESPACE::DataTransfer::ThrowException(Isolate, "Invalid argument!");
|
|
}
|
|
|
|
static void FQuatM_op_BitwiseOr(const v8::FunctionCallbackInfo<v8::Value>& Info)
|
|
{
|
|
v8::Isolate* Isolate = Info.GetIsolate();
|
|
v8::Local<v8::Context> Context = Isolate->GetCurrentContext();
|
|
if (Info.Length() == 1)
|
|
{
|
|
if (Info[0]->IsObject() &&
|
|
|
|
PUERTS_NAMESPACE::DataTransfer::IsInstanceOf<FQuat>(Isolate, Info[0]->ToObject(Context).ToLocalChecked()))
|
|
{
|
|
const FQuat* Arg0 = PUERTS_NAMESPACE::DataTransfer::GetPointerFast<FQuat>(Info[0]->ToObject(Context).ToLocalChecked());
|
|
auto Self = PUERTS_NAMESPACE::DataTransfer::GetPointerFast<FQuat>(Info.Holder());
|
|
if (!Self)
|
|
{
|
|
PUERTS_NAMESPACE::DataTransfer::ThrowException(
|
|
Isolate, "[FQuat::M_op_BitwiseOr] Attempt to access a NULL self pointer");
|
|
return;
|
|
}
|
|
auto MethodResult = Self->operator|(*Arg0);
|
|
auto V8Result = v8::Number::New(Isolate, MethodResult);
|
|
Info.GetReturnValue().Set(V8Result);
|
|
|
|
return;
|
|
}
|
|
}
|
|
PUERTS_NAMESPACE::DataTransfer::ThrowException(Isolate, "Invalid argument!");
|
|
}
|
|
|
|
static void FQuatS_MakeFromEuler(const v8::FunctionCallbackInfo<v8::Value>& Info)
|
|
{
|
|
v8::Isolate* Isolate = Info.GetIsolate();
|
|
v8::Local<v8::Context> Context = Isolate->GetCurrentContext();
|
|
if (Info.Length() == 1)
|
|
{
|
|
if (Info[0]->IsObject() &&
|
|
|
|
PUERTS_NAMESPACE::DataTransfer::IsInstanceOf<FVector>(Isolate, Info[0]->ToObject(Context).ToLocalChecked()))
|
|
{
|
|
const FVector* Arg0 =
|
|
PUERTS_NAMESPACE::DataTransfer::GetPointerFast<FVector>(Info[0]->ToObject(Context).ToLocalChecked());
|
|
auto MethodResult = FQuat::MakeFromEuler(*Arg0);
|
|
void* Ptr = new FQuat(MethodResult);
|
|
|
|
auto V8Result = PUERTS_NAMESPACE::DataTransfer::FindOrAddStruct<FQuat>(Isolate, Context, Ptr, false);
|
|
|
|
Info.GetReturnValue().Set(V8Result);
|
|
|
|
return;
|
|
}
|
|
}
|
|
PUERTS_NAMESPACE::DataTransfer::ThrowException(Isolate, "Invalid argument!");
|
|
}
|
|
|
|
static void FQuatM_Euler(const v8::FunctionCallbackInfo<v8::Value>& Info)
|
|
{
|
|
v8::Isolate* Isolate = Info.GetIsolate();
|
|
v8::Local<v8::Context> Context = Isolate->GetCurrentContext();
|
|
if (Info.Length() == 0)
|
|
{
|
|
if (true)
|
|
{
|
|
auto Self = PUERTS_NAMESPACE::DataTransfer::GetPointerFast<FQuat>(Info.Holder());
|
|
if (!Self)
|
|
{
|
|
PUERTS_NAMESPACE::DataTransfer::ThrowException(Isolate, "[FQuat::M_Euler] Attempt to access a NULL self pointer");
|
|
return;
|
|
}
|
|
auto MethodResult = Self->Euler();
|
|
void* Ptr = new FVector(MethodResult);
|
|
|
|
auto V8Result = PUERTS_NAMESPACE::DataTransfer::FindOrAddStruct<FVector>(Isolate, Context, Ptr, false);
|
|
|
|
Info.GetReturnValue().Set(V8Result);
|
|
|
|
return;
|
|
}
|
|
}
|
|
PUERTS_NAMESPACE::DataTransfer::ThrowException(Isolate, "Invalid argument!");
|
|
}
|
|
|
|
static void FQuatM_Normalize(const v8::FunctionCallbackInfo<v8::Value>& Info)
|
|
{
|
|
v8::Isolate* Isolate = Info.GetIsolate();
|
|
v8::Local<v8::Context> Context = Isolate->GetCurrentContext();
|
|
if (Info.Length() == 1)
|
|
{
|
|
if (Info[0]->IsNumber())
|
|
{
|
|
float Arg0 = Info[0]->ToNumber(Context).ToLocalChecked()->Value();
|
|
auto Self = PUERTS_NAMESPACE::DataTransfer::GetPointerFast<FQuat>(Info.Holder());
|
|
if (!Self)
|
|
{
|
|
PUERTS_NAMESPACE::DataTransfer::ThrowException(
|
|
Isolate, "[FQuat::M_Normalize] Attempt to access a NULL self pointer");
|
|
return;
|
|
}
|
|
Self->Normalize(Arg0);
|
|
|
|
return;
|
|
}
|
|
}
|
|
PUERTS_NAMESPACE::DataTransfer::ThrowException(Isolate, "Invalid argument!");
|
|
}
|
|
|
|
static void FQuatM_GetNormalized(const v8::FunctionCallbackInfo<v8::Value>& Info)
|
|
{
|
|
v8::Isolate* Isolate = Info.GetIsolate();
|
|
v8::Local<v8::Context> Context = Isolate->GetCurrentContext();
|
|
if (Info.Length() == 1)
|
|
{
|
|
if (Info[0]->IsNumber())
|
|
{
|
|
float Arg0 = Info[0]->ToNumber(Context).ToLocalChecked()->Value();
|
|
auto Self = PUERTS_NAMESPACE::DataTransfer::GetPointerFast<FQuat>(Info.Holder());
|
|
if (!Self)
|
|
{
|
|
PUERTS_NAMESPACE::DataTransfer::ThrowException(
|
|
Isolate, "[FQuat::M_GetNormalized] Attempt to access a NULL self pointer");
|
|
return;
|
|
}
|
|
auto MethodResult = Self->GetNormalized(Arg0);
|
|
void* Ptr = new FQuat(MethodResult);
|
|
|
|
auto V8Result = PUERTS_NAMESPACE::DataTransfer::FindOrAddStruct<FQuat>(Isolate, Context, Ptr, false);
|
|
|
|
Info.GetReturnValue().Set(V8Result);
|
|
|
|
return;
|
|
}
|
|
}
|
|
PUERTS_NAMESPACE::DataTransfer::ThrowException(Isolate, "Invalid argument!");
|
|
}
|
|
|
|
static void FQuatM_IsNormalized(const v8::FunctionCallbackInfo<v8::Value>& Info)
|
|
{
|
|
v8::Isolate* Isolate = Info.GetIsolate();
|
|
v8::Local<v8::Context> Context = Isolate->GetCurrentContext();
|
|
if (Info.Length() == 0)
|
|
{
|
|
if (true)
|
|
{
|
|
auto Self = PUERTS_NAMESPACE::DataTransfer::GetPointerFast<FQuat>(Info.Holder());
|
|
if (!Self)
|
|
{
|
|
PUERTS_NAMESPACE::DataTransfer::ThrowException(
|
|
Isolate, "[FQuat::M_IsNormalized] Attempt to access a NULL self pointer");
|
|
return;
|
|
}
|
|
auto MethodResult = Self->IsNormalized();
|
|
auto V8Result = v8::Boolean::New(Isolate, MethodResult);
|
|
Info.GetReturnValue().Set(V8Result);
|
|
|
|
return;
|
|
}
|
|
}
|
|
PUERTS_NAMESPACE::DataTransfer::ThrowException(Isolate, "Invalid argument!");
|
|
}
|
|
|
|
static void FQuatM_Size(const v8::FunctionCallbackInfo<v8::Value>& Info)
|
|
{
|
|
v8::Isolate* Isolate = Info.GetIsolate();
|
|
v8::Local<v8::Context> Context = Isolate->GetCurrentContext();
|
|
if (Info.Length() == 0)
|
|
{
|
|
if (true)
|
|
{
|
|
auto Self = PUERTS_NAMESPACE::DataTransfer::GetPointerFast<FQuat>(Info.Holder());
|
|
if (!Self)
|
|
{
|
|
PUERTS_NAMESPACE::DataTransfer::ThrowException(Isolate, "[FQuat::M_Size] Attempt to access a NULL self pointer");
|
|
return;
|
|
}
|
|
auto MethodResult = Self->Size();
|
|
auto V8Result = v8::Number::New(Isolate, MethodResult);
|
|
Info.GetReturnValue().Set(V8Result);
|
|
|
|
return;
|
|
}
|
|
}
|
|
PUERTS_NAMESPACE::DataTransfer::ThrowException(Isolate, "Invalid argument!");
|
|
}
|
|
|
|
static void FQuatM_SizeSquared(const v8::FunctionCallbackInfo<v8::Value>& Info)
|
|
{
|
|
v8::Isolate* Isolate = Info.GetIsolate();
|
|
v8::Local<v8::Context> Context = Isolate->GetCurrentContext();
|
|
if (Info.Length() == 0)
|
|
{
|
|
if (true)
|
|
{
|
|
auto Self = PUERTS_NAMESPACE::DataTransfer::GetPointerFast<FQuat>(Info.Holder());
|
|
if (!Self)
|
|
{
|
|
PUERTS_NAMESPACE::DataTransfer::ThrowException(
|
|
Isolate, "[FQuat::M_SizeSquared] Attempt to access a NULL self pointer");
|
|
return;
|
|
}
|
|
auto MethodResult = Self->SizeSquared();
|
|
auto V8Result = v8::Number::New(Isolate, MethodResult);
|
|
Info.GetReturnValue().Set(V8Result);
|
|
|
|
return;
|
|
}
|
|
}
|
|
PUERTS_NAMESPACE::DataTransfer::ThrowException(Isolate, "Invalid argument!");
|
|
}
|
|
|
|
static void FQuatM_GetAngle(const v8::FunctionCallbackInfo<v8::Value>& Info)
|
|
{
|
|
v8::Isolate* Isolate = Info.GetIsolate();
|
|
v8::Local<v8::Context> Context = Isolate->GetCurrentContext();
|
|
if (Info.Length() == 0)
|
|
{
|
|
if (true)
|
|
{
|
|
auto Self = PUERTS_NAMESPACE::DataTransfer::GetPointerFast<FQuat>(Info.Holder());
|
|
if (!Self)
|
|
{
|
|
PUERTS_NAMESPACE::DataTransfer::ThrowException(
|
|
Isolate, "[FQuat::M_GetAngle] Attempt to access a NULL self pointer");
|
|
return;
|
|
}
|
|
auto MethodResult = Self->GetAngle();
|
|
auto V8Result = v8::Number::New(Isolate, MethodResult);
|
|
Info.GetReturnValue().Set(V8Result);
|
|
|
|
return;
|
|
}
|
|
}
|
|
PUERTS_NAMESPACE::DataTransfer::ThrowException(Isolate, "Invalid argument!");
|
|
}
|
|
|
|
static void FQuatM_ToAxisAndAngle(const v8::FunctionCallbackInfo<v8::Value>& Info)
|
|
{
|
|
v8::Isolate* Isolate = Info.GetIsolate();
|
|
v8::Local<v8::Context> Context = Isolate->GetCurrentContext();
|
|
if (Info.Length() == 2)
|
|
{
|
|
if (Info[0]->IsObject() && PUERTS_NAMESPACE::DataTransfer::UnRef(Isolate, Info[0])->IsObject() &&
|
|
|
|
PUERTS_NAMESPACE::DataTransfer::IsInstanceOf<FVector>(
|
|
Isolate, PUERTS_NAMESPACE::DataTransfer::UnRef(Isolate, Info[0])->ToObject(Context).ToLocalChecked()) &&
|
|
Info[1]->IsObject() && PUERTS_NAMESPACE::DataTransfer::UnRef(Isolate, Info[1])->IsNumber())
|
|
{
|
|
FVector* Arg0 = PUERTS_NAMESPACE::DataTransfer::GetPointerFast<FVector>(
|
|
PUERTS_NAMESPACE::DataTransfer::UnRef(Isolate, Info[0])->ToObject(Context).ToLocalChecked());
|
|
float Arg1 = PUERTS_NAMESPACE::DataTransfer::UnRef(Isolate, Info[1])->ToNumber(Context).ToLocalChecked()->Value();
|
|
auto Self = PUERTS_NAMESPACE::DataTransfer::GetPointerFast<FQuat>(Info.Holder());
|
|
if (!Self)
|
|
{
|
|
PUERTS_NAMESPACE::DataTransfer::ThrowException(
|
|
Isolate, "[FQuat::M_ToAxisAndAngle] Attempt to access a NULL self pointer");
|
|
return;
|
|
}
|
|
Self->ToAxisAndAngle(*Arg0, Arg1);
|
|
|
|
PUERTS_NAMESPACE::DataTransfer::UpdateRef(Isolate, Info[1], v8::Number::New(Isolate, Arg1));
|
|
return;
|
|
}
|
|
}
|
|
PUERTS_NAMESPACE::DataTransfer::ThrowException(Isolate, "Invalid argument!");
|
|
}
|
|
|
|
static void FQuatM_ToSwingTwist(const v8::FunctionCallbackInfo<v8::Value>& Info)
|
|
{
|
|
v8::Isolate* Isolate = Info.GetIsolate();
|
|
v8::Local<v8::Context> Context = Isolate->GetCurrentContext();
|
|
if (Info.Length() == 3)
|
|
{
|
|
if (Info[0]->IsObject() &&
|
|
|
|
PUERTS_NAMESPACE::DataTransfer::IsInstanceOf<FVector>(Isolate, Info[0]->ToObject(Context).ToLocalChecked()) &&
|
|
Info[1]->IsObject() && PUERTS_NAMESPACE::DataTransfer::UnRef(Isolate, Info[1])->IsObject() &&
|
|
|
|
PUERTS_NAMESPACE::DataTransfer::IsInstanceOf<FQuat>(
|
|
Isolate, PUERTS_NAMESPACE::DataTransfer::UnRef(Isolate, Info[1])->ToObject(Context).ToLocalChecked()) &&
|
|
Info[2]->IsObject() && PUERTS_NAMESPACE::DataTransfer::UnRef(Isolate, Info[2])->IsObject() &&
|
|
|
|
PUERTS_NAMESPACE::DataTransfer::IsInstanceOf<FQuat>(
|
|
Isolate, PUERTS_NAMESPACE::DataTransfer::UnRef(Isolate, Info[2])->ToObject(Context).ToLocalChecked()))
|
|
{
|
|
const FVector* Arg0 =
|
|
PUERTS_NAMESPACE::DataTransfer::GetPointerFast<FVector>(Info[0]->ToObject(Context).ToLocalChecked());
|
|
FQuat* Arg1 = PUERTS_NAMESPACE::DataTransfer::GetPointerFast<FQuat>(
|
|
PUERTS_NAMESPACE::DataTransfer::UnRef(Isolate, Info[1])->ToObject(Context).ToLocalChecked());
|
|
FQuat* Arg2 = PUERTS_NAMESPACE::DataTransfer::GetPointerFast<FQuat>(
|
|
PUERTS_NAMESPACE::DataTransfer::UnRef(Isolate, Info[2])->ToObject(Context).ToLocalChecked());
|
|
auto Self = PUERTS_NAMESPACE::DataTransfer::GetPointerFast<FQuat>(Info.Holder());
|
|
if (!Self)
|
|
{
|
|
PUERTS_NAMESPACE::DataTransfer::ThrowException(
|
|
Isolate, "[FQuat::M_ToSwingTwist] Attempt to access a NULL self pointer");
|
|
return;
|
|
}
|
|
Self->ToSwingTwist(*Arg0, *Arg1, *Arg2);
|
|
|
|
return;
|
|
}
|
|
}
|
|
PUERTS_NAMESPACE::DataTransfer::ThrowException(Isolate, "Invalid argument!");
|
|
}
|
|
|
|
static void FQuatM_RotateVector(const v8::FunctionCallbackInfo<v8::Value>& Info)
|
|
{
|
|
v8::Isolate* Isolate = Info.GetIsolate();
|
|
v8::Local<v8::Context> Context = Isolate->GetCurrentContext();
|
|
if (Info.Length() == 1)
|
|
{
|
|
if (Info[0]->IsObject() &&
|
|
|
|
PUERTS_NAMESPACE::DataTransfer::IsInstanceOf<FVector>(Isolate, Info[0]->ToObject(Context).ToLocalChecked()))
|
|
{
|
|
FVector* Arg0 = PUERTS_NAMESPACE::DataTransfer::GetPointerFast<FVector>(Info[0]->ToObject(Context).ToLocalChecked());
|
|
auto Self = PUERTS_NAMESPACE::DataTransfer::GetPointerFast<FQuat>(Info.Holder());
|
|
if (!Self)
|
|
{
|
|
PUERTS_NAMESPACE::DataTransfer::ThrowException(
|
|
Isolate, "[FQuat::M_RotateVector] Attempt to access a NULL self pointer");
|
|
return;
|
|
}
|
|
auto MethodResult = Self->RotateVector(*Arg0);
|
|
void* Ptr = new FVector(MethodResult);
|
|
|
|
auto V8Result = PUERTS_NAMESPACE::DataTransfer::FindOrAddStruct<FVector>(Isolate, Context, Ptr, false);
|
|
|
|
Info.GetReturnValue().Set(V8Result);
|
|
|
|
return;
|
|
}
|
|
}
|
|
PUERTS_NAMESPACE::DataTransfer::ThrowException(Isolate, "Invalid argument!");
|
|
}
|
|
|
|
static void FQuatM_UnrotateVector(const v8::FunctionCallbackInfo<v8::Value>& Info)
|
|
{
|
|
v8::Isolate* Isolate = Info.GetIsolate();
|
|
v8::Local<v8::Context> Context = Isolate->GetCurrentContext();
|
|
if (Info.Length() == 1)
|
|
{
|
|
if (Info[0]->IsObject() &&
|
|
|
|
PUERTS_NAMESPACE::DataTransfer::IsInstanceOf<FVector>(Isolate, Info[0]->ToObject(Context).ToLocalChecked()))
|
|
{
|
|
FVector* Arg0 = PUERTS_NAMESPACE::DataTransfer::GetPointerFast<FVector>(Info[0]->ToObject(Context).ToLocalChecked());
|
|
auto Self = PUERTS_NAMESPACE::DataTransfer::GetPointerFast<FQuat>(Info.Holder());
|
|
if (!Self)
|
|
{
|
|
PUERTS_NAMESPACE::DataTransfer::ThrowException(
|
|
Isolate, "[FQuat::M_UnrotateVector] Attempt to access a NULL self pointer");
|
|
return;
|
|
}
|
|
auto MethodResult = Self->UnrotateVector(*Arg0);
|
|
void* Ptr = new FVector(MethodResult);
|
|
|
|
auto V8Result = PUERTS_NAMESPACE::DataTransfer::FindOrAddStruct<FVector>(Isolate, Context, Ptr, false);
|
|
|
|
Info.GetReturnValue().Set(V8Result);
|
|
|
|
return;
|
|
}
|
|
}
|
|
PUERTS_NAMESPACE::DataTransfer::ThrowException(Isolate, "Invalid argument!");
|
|
}
|
|
|
|
static void FQuatM_Log(const v8::FunctionCallbackInfo<v8::Value>& Info)
|
|
{
|
|
v8::Isolate* Isolate = Info.GetIsolate();
|
|
v8::Local<v8::Context> Context = Isolate->GetCurrentContext();
|
|
if (Info.Length() == 0)
|
|
{
|
|
if (true)
|
|
{
|
|
auto Self = PUERTS_NAMESPACE::DataTransfer::GetPointerFast<FQuat>(Info.Holder());
|
|
if (!Self)
|
|
{
|
|
PUERTS_NAMESPACE::DataTransfer::ThrowException(Isolate, "[FQuat::M_Log] Attempt to access a NULL self pointer");
|
|
return;
|
|
}
|
|
auto MethodResult = Self->Log();
|
|
void* Ptr = new FQuat(MethodResult);
|
|
|
|
auto V8Result = PUERTS_NAMESPACE::DataTransfer::FindOrAddStruct<FQuat>(Isolate, Context, Ptr, false);
|
|
|
|
Info.GetReturnValue().Set(V8Result);
|
|
|
|
return;
|
|
}
|
|
}
|
|
PUERTS_NAMESPACE::DataTransfer::ThrowException(Isolate, "Invalid argument!");
|
|
}
|
|
|
|
static void FQuatM_Exp(const v8::FunctionCallbackInfo<v8::Value>& Info)
|
|
{
|
|
v8::Isolate* Isolate = Info.GetIsolate();
|
|
v8::Local<v8::Context> Context = Isolate->GetCurrentContext();
|
|
if (Info.Length() == 0)
|
|
{
|
|
if (true)
|
|
{
|
|
auto Self = PUERTS_NAMESPACE::DataTransfer::GetPointerFast<FQuat>(Info.Holder());
|
|
if (!Self)
|
|
{
|
|
PUERTS_NAMESPACE::DataTransfer::ThrowException(Isolate, "[FQuat::M_Exp] Attempt to access a NULL self pointer");
|
|
return;
|
|
}
|
|
auto MethodResult = Self->Exp();
|
|
void* Ptr = new FQuat(MethodResult);
|
|
|
|
auto V8Result = PUERTS_NAMESPACE::DataTransfer::FindOrAddStruct<FQuat>(Isolate, Context, Ptr, false);
|
|
|
|
Info.GetReturnValue().Set(V8Result);
|
|
|
|
return;
|
|
}
|
|
}
|
|
PUERTS_NAMESPACE::DataTransfer::ThrowException(Isolate, "Invalid argument!");
|
|
}
|
|
|
|
static void FQuatM_Inverse(const v8::FunctionCallbackInfo<v8::Value>& Info)
|
|
{
|
|
v8::Isolate* Isolate = Info.GetIsolate();
|
|
v8::Local<v8::Context> Context = Isolate->GetCurrentContext();
|
|
if (Info.Length() == 0)
|
|
{
|
|
if (true)
|
|
{
|
|
auto Self = PUERTS_NAMESPACE::DataTransfer::GetPointerFast<FQuat>(Info.Holder());
|
|
if (!Self)
|
|
{
|
|
PUERTS_NAMESPACE::DataTransfer::ThrowException(Isolate, "[FQuat::M_Inverse] Attempt to access a NULL self pointer");
|
|
return;
|
|
}
|
|
auto MethodResult = Self->Inverse();
|
|
void* Ptr = new FQuat(MethodResult);
|
|
|
|
auto V8Result = PUERTS_NAMESPACE::DataTransfer::FindOrAddStruct<FQuat>(Isolate, Context, Ptr, false);
|
|
|
|
Info.GetReturnValue().Set(V8Result);
|
|
|
|
return;
|
|
}
|
|
}
|
|
PUERTS_NAMESPACE::DataTransfer::ThrowException(Isolate, "Invalid argument!");
|
|
}
|
|
|
|
static void FQuatM_EnforceShortestArcWith(const v8::FunctionCallbackInfo<v8::Value>& Info)
|
|
{
|
|
v8::Isolate* Isolate = Info.GetIsolate();
|
|
v8::Local<v8::Context> Context = Isolate->GetCurrentContext();
|
|
if (Info.Length() == 1)
|
|
{
|
|
if (Info[0]->IsObject() &&
|
|
|
|
PUERTS_NAMESPACE::DataTransfer::IsInstanceOf<FQuat>(Isolate, Info[0]->ToObject(Context).ToLocalChecked()))
|
|
{
|
|
const FQuat* Arg0 = PUERTS_NAMESPACE::DataTransfer::GetPointerFast<FQuat>(Info[0]->ToObject(Context).ToLocalChecked());
|
|
auto Self = PUERTS_NAMESPACE::DataTransfer::GetPointerFast<FQuat>(Info.Holder());
|
|
if (!Self)
|
|
{
|
|
PUERTS_NAMESPACE::DataTransfer::ThrowException(
|
|
Isolate, "[FQuat::M_EnforceShortestArcWith] Attempt to access a NULL self pointer");
|
|
return;
|
|
}
|
|
Self->EnforceShortestArcWith(*Arg0);
|
|
|
|
return;
|
|
}
|
|
}
|
|
PUERTS_NAMESPACE::DataTransfer::ThrowException(Isolate, "Invalid argument!");
|
|
}
|
|
|
|
static void FQuatM_GetAxisX(const v8::FunctionCallbackInfo<v8::Value>& Info)
|
|
{
|
|
v8::Isolate* Isolate = Info.GetIsolate();
|
|
v8::Local<v8::Context> Context = Isolate->GetCurrentContext();
|
|
if (Info.Length() == 0)
|
|
{
|
|
if (true)
|
|
{
|
|
auto Self = PUERTS_NAMESPACE::DataTransfer::GetPointerFast<FQuat>(Info.Holder());
|
|
if (!Self)
|
|
{
|
|
PUERTS_NAMESPACE::DataTransfer::ThrowException(
|
|
Isolate, "[FQuat::M_GetAxisX] Attempt to access a NULL self pointer");
|
|
return;
|
|
}
|
|
auto MethodResult = Self->GetAxisX();
|
|
void* Ptr = new FVector(MethodResult);
|
|
|
|
auto V8Result = PUERTS_NAMESPACE::DataTransfer::FindOrAddStruct<FVector>(Isolate, Context, Ptr, false);
|
|
|
|
Info.GetReturnValue().Set(V8Result);
|
|
|
|
return;
|
|
}
|
|
}
|
|
PUERTS_NAMESPACE::DataTransfer::ThrowException(Isolate, "Invalid argument!");
|
|
}
|
|
|
|
static void FQuatM_GetAxisY(const v8::FunctionCallbackInfo<v8::Value>& Info)
|
|
{
|
|
v8::Isolate* Isolate = Info.GetIsolate();
|
|
v8::Local<v8::Context> Context = Isolate->GetCurrentContext();
|
|
if (Info.Length() == 0)
|
|
{
|
|
if (true)
|
|
{
|
|
auto Self = PUERTS_NAMESPACE::DataTransfer::GetPointerFast<FQuat>(Info.Holder());
|
|
if (!Self)
|
|
{
|
|
PUERTS_NAMESPACE::DataTransfer::ThrowException(
|
|
Isolate, "[FQuat::M_GetAxisY] Attempt to access a NULL self pointer");
|
|
return;
|
|
}
|
|
auto MethodResult = Self->GetAxisY();
|
|
void* Ptr = new FVector(MethodResult);
|
|
|
|
auto V8Result = PUERTS_NAMESPACE::DataTransfer::FindOrAddStruct<FVector>(Isolate, Context, Ptr, false);
|
|
|
|
Info.GetReturnValue().Set(V8Result);
|
|
|
|
return;
|
|
}
|
|
}
|
|
PUERTS_NAMESPACE::DataTransfer::ThrowException(Isolate, "Invalid argument!");
|
|
}
|
|
|
|
static void FQuatM_GetAxisZ(const v8::FunctionCallbackInfo<v8::Value>& Info)
|
|
{
|
|
v8::Isolate* Isolate = Info.GetIsolate();
|
|
v8::Local<v8::Context> Context = Isolate->GetCurrentContext();
|
|
if (Info.Length() == 0)
|
|
{
|
|
if (true)
|
|
{
|
|
auto Self = PUERTS_NAMESPACE::DataTransfer::GetPointerFast<FQuat>(Info.Holder());
|
|
if (!Self)
|
|
{
|
|
PUERTS_NAMESPACE::DataTransfer::ThrowException(
|
|
Isolate, "[FQuat::M_GetAxisZ] Attempt to access a NULL self pointer");
|
|
return;
|
|
}
|
|
auto MethodResult = Self->GetAxisZ();
|
|
void* Ptr = new FVector(MethodResult);
|
|
|
|
auto V8Result = PUERTS_NAMESPACE::DataTransfer::FindOrAddStruct<FVector>(Isolate, Context, Ptr, false);
|
|
|
|
Info.GetReturnValue().Set(V8Result);
|
|
|
|
return;
|
|
}
|
|
}
|
|
PUERTS_NAMESPACE::DataTransfer::ThrowException(Isolate, "Invalid argument!");
|
|
}
|
|
|
|
static void FQuatM_GetForwardVector(const v8::FunctionCallbackInfo<v8::Value>& Info)
|
|
{
|
|
v8::Isolate* Isolate = Info.GetIsolate();
|
|
v8::Local<v8::Context> Context = Isolate->GetCurrentContext();
|
|
if (Info.Length() == 0)
|
|
{
|
|
if (true)
|
|
{
|
|
auto Self = PUERTS_NAMESPACE::DataTransfer::GetPointerFast<FQuat>(Info.Holder());
|
|
if (!Self)
|
|
{
|
|
PUERTS_NAMESPACE::DataTransfer::ThrowException(
|
|
Isolate, "[FQuat::M_GetForwardVector] Attempt to access a NULL self pointer");
|
|
return;
|
|
}
|
|
auto MethodResult = Self->GetForwardVector();
|
|
void* Ptr = new FVector(MethodResult);
|
|
|
|
auto V8Result = PUERTS_NAMESPACE::DataTransfer::FindOrAddStruct<FVector>(Isolate, Context, Ptr, false);
|
|
|
|
Info.GetReturnValue().Set(V8Result);
|
|
|
|
return;
|
|
}
|
|
}
|
|
PUERTS_NAMESPACE::DataTransfer::ThrowException(Isolate, "Invalid argument!");
|
|
}
|
|
|
|
static void FQuatM_GetRightVector(const v8::FunctionCallbackInfo<v8::Value>& Info)
|
|
{
|
|
v8::Isolate* Isolate = Info.GetIsolate();
|
|
v8::Local<v8::Context> Context = Isolate->GetCurrentContext();
|
|
if (Info.Length() == 0)
|
|
{
|
|
if (true)
|
|
{
|
|
auto Self = PUERTS_NAMESPACE::DataTransfer::GetPointerFast<FQuat>(Info.Holder());
|
|
if (!Self)
|
|
{
|
|
PUERTS_NAMESPACE::DataTransfer::ThrowException(
|
|
Isolate, "[FQuat::M_GetRightVector] Attempt to access a NULL self pointer");
|
|
return;
|
|
}
|
|
auto MethodResult = Self->GetRightVector();
|
|
void* Ptr = new FVector(MethodResult);
|
|
|
|
auto V8Result = PUERTS_NAMESPACE::DataTransfer::FindOrAddStruct<FVector>(Isolate, Context, Ptr, false);
|
|
|
|
Info.GetReturnValue().Set(V8Result);
|
|
|
|
return;
|
|
}
|
|
}
|
|
PUERTS_NAMESPACE::DataTransfer::ThrowException(Isolate, "Invalid argument!");
|
|
}
|
|
|
|
static void FQuatM_GetUpVector(const v8::FunctionCallbackInfo<v8::Value>& Info)
|
|
{
|
|
v8::Isolate* Isolate = Info.GetIsolate();
|
|
v8::Local<v8::Context> Context = Isolate->GetCurrentContext();
|
|
if (Info.Length() == 0)
|
|
{
|
|
if (true)
|
|
{
|
|
auto Self = PUERTS_NAMESPACE::DataTransfer::GetPointerFast<FQuat>(Info.Holder());
|
|
if (!Self)
|
|
{
|
|
PUERTS_NAMESPACE::DataTransfer::ThrowException(
|
|
Isolate, "[FQuat::M_GetUpVector] Attempt to access a NULL self pointer");
|
|
return;
|
|
}
|
|
auto MethodResult = Self->GetUpVector();
|
|
void* Ptr = new FVector(MethodResult);
|
|
|
|
auto V8Result = PUERTS_NAMESPACE::DataTransfer::FindOrAddStruct<FVector>(Isolate, Context, Ptr, false);
|
|
|
|
Info.GetReturnValue().Set(V8Result);
|
|
|
|
return;
|
|
}
|
|
}
|
|
PUERTS_NAMESPACE::DataTransfer::ThrowException(Isolate, "Invalid argument!");
|
|
}
|
|
|
|
static void FQuatM_Vector(const v8::FunctionCallbackInfo<v8::Value>& Info)
|
|
{
|
|
v8::Isolate* Isolate = Info.GetIsolate();
|
|
v8::Local<v8::Context> Context = Isolate->GetCurrentContext();
|
|
if (Info.Length() == 0)
|
|
{
|
|
if (true)
|
|
{
|
|
auto Self = PUERTS_NAMESPACE::DataTransfer::GetPointerFast<FQuat>(Info.Holder());
|
|
if (!Self)
|
|
{
|
|
PUERTS_NAMESPACE::DataTransfer::ThrowException(Isolate, "[FQuat::M_Vector] Attempt to access a NULL self pointer");
|
|
return;
|
|
}
|
|
auto MethodResult = Self->Vector();
|
|
void* Ptr = new FVector(MethodResult);
|
|
|
|
auto V8Result = PUERTS_NAMESPACE::DataTransfer::FindOrAddStruct<FVector>(Isolate, Context, Ptr, false);
|
|
|
|
Info.GetReturnValue().Set(V8Result);
|
|
|
|
return;
|
|
}
|
|
}
|
|
PUERTS_NAMESPACE::DataTransfer::ThrowException(Isolate, "Invalid argument!");
|
|
}
|
|
|
|
static void FQuatM_Rotator(const v8::FunctionCallbackInfo<v8::Value>& Info)
|
|
{
|
|
v8::Isolate* Isolate = Info.GetIsolate();
|
|
v8::Local<v8::Context> Context = Isolate->GetCurrentContext();
|
|
if (Info.Length() == 0)
|
|
{
|
|
if (true)
|
|
{
|
|
auto Self = PUERTS_NAMESPACE::DataTransfer::GetPointerFast<FQuat>(Info.Holder());
|
|
if (!Self)
|
|
{
|
|
PUERTS_NAMESPACE::DataTransfer::ThrowException(Isolate, "[FQuat::M_Rotator] Attempt to access a NULL self pointer");
|
|
return;
|
|
}
|
|
auto MethodResult = Self->Rotator();
|
|
void* Ptr = new FRotator(MethodResult);
|
|
|
|
auto V8Result = PUERTS_NAMESPACE::DataTransfer::FindOrAddStruct<FRotator>(Isolate, Context, Ptr, false);
|
|
|
|
Info.GetReturnValue().Set(V8Result);
|
|
|
|
return;
|
|
}
|
|
}
|
|
PUERTS_NAMESPACE::DataTransfer::ThrowException(Isolate, "Invalid argument!");
|
|
}
|
|
|
|
static void FQuatM_GetRotationAxis(const v8::FunctionCallbackInfo<v8::Value>& Info)
|
|
{
|
|
v8::Isolate* Isolate = Info.GetIsolate();
|
|
v8::Local<v8::Context> Context = Isolate->GetCurrentContext();
|
|
if (Info.Length() == 0)
|
|
{
|
|
if (true)
|
|
{
|
|
auto Self = PUERTS_NAMESPACE::DataTransfer::GetPointerFast<FQuat>(Info.Holder());
|
|
if (!Self)
|
|
{
|
|
PUERTS_NAMESPACE::DataTransfer::ThrowException(
|
|
Isolate, "[FQuat::M_GetRotationAxis] Attempt to access a NULL self pointer");
|
|
return;
|
|
}
|
|
auto MethodResult = Self->GetRotationAxis();
|
|
void* Ptr = new FVector(MethodResult);
|
|
|
|
auto V8Result = PUERTS_NAMESPACE::DataTransfer::FindOrAddStruct<FVector>(Isolate, Context, Ptr, false);
|
|
|
|
Info.GetReturnValue().Set(V8Result);
|
|
|
|
return;
|
|
}
|
|
}
|
|
PUERTS_NAMESPACE::DataTransfer::ThrowException(Isolate, "Invalid argument!");
|
|
}
|
|
|
|
static void FQuatM_AngularDistance(const v8::FunctionCallbackInfo<v8::Value>& Info)
|
|
{
|
|
v8::Isolate* Isolate = Info.GetIsolate();
|
|
v8::Local<v8::Context> Context = Isolate->GetCurrentContext();
|
|
if (Info.Length() == 1)
|
|
{
|
|
if (Info[0]->IsObject() &&
|
|
|
|
PUERTS_NAMESPACE::DataTransfer::IsInstanceOf<FQuat>(Isolate, Info[0]->ToObject(Context).ToLocalChecked()))
|
|
{
|
|
const FQuat* Arg0 = PUERTS_NAMESPACE::DataTransfer::GetPointerFast<FQuat>(Info[0]->ToObject(Context).ToLocalChecked());
|
|
auto Self = PUERTS_NAMESPACE::DataTransfer::GetPointerFast<FQuat>(Info.Holder());
|
|
if (!Self)
|
|
{
|
|
PUERTS_NAMESPACE::DataTransfer::ThrowException(
|
|
Isolate, "[FQuat::M_AngularDistance] Attempt to access a NULL self pointer");
|
|
return;
|
|
}
|
|
auto MethodResult = Self->AngularDistance(*Arg0);
|
|
auto V8Result = v8::Number::New(Isolate, MethodResult);
|
|
Info.GetReturnValue().Set(V8Result);
|
|
|
|
return;
|
|
}
|
|
}
|
|
PUERTS_NAMESPACE::DataTransfer::ThrowException(Isolate, "Invalid argument!");
|
|
}
|
|
|
|
static void FQuatM_ContainsNaN(const v8::FunctionCallbackInfo<v8::Value>& Info)
|
|
{
|
|
v8::Isolate* Isolate = Info.GetIsolate();
|
|
v8::Local<v8::Context> Context = Isolate->GetCurrentContext();
|
|
if (Info.Length() == 0)
|
|
{
|
|
if (true)
|
|
{
|
|
auto Self = PUERTS_NAMESPACE::DataTransfer::GetPointerFast<FQuat>(Info.Holder());
|
|
if (!Self)
|
|
{
|
|
PUERTS_NAMESPACE::DataTransfer::ThrowException(
|
|
Isolate, "[FQuat::M_ContainsNaN] Attempt to access a NULL self pointer");
|
|
return;
|
|
}
|
|
auto MethodResult = Self->ContainsNaN();
|
|
auto V8Result = v8::Boolean::New(Isolate, MethodResult);
|
|
Info.GetReturnValue().Set(V8Result);
|
|
|
|
return;
|
|
}
|
|
}
|
|
PUERTS_NAMESPACE::DataTransfer::ThrowException(Isolate, "Invalid argument!");
|
|
}
|
|
|
|
static void FQuatM_ToString(const v8::FunctionCallbackInfo<v8::Value>& Info)
|
|
{
|
|
v8::Isolate* Isolate = Info.GetIsolate();
|
|
v8::Local<v8::Context> Context = Isolate->GetCurrentContext();
|
|
if (Info.Length() == 0)
|
|
{
|
|
if (true)
|
|
{
|
|
auto Self = PUERTS_NAMESPACE::DataTransfer::GetPointerFast<FQuat>(Info.Holder());
|
|
if (!Self)
|
|
{
|
|
PUERTS_NAMESPACE::DataTransfer::ThrowException(
|
|
Isolate, "[FQuat::M_ToString] Attempt to access a NULL self pointer");
|
|
return;
|
|
}
|
|
auto MethodResult = Self->ToString();
|
|
auto V8Result =
|
|
v8::String::NewFromUtf8(Isolate, TCHAR_TO_UTF8(*MethodResult), v8::NewStringType::kNormal).ToLocalChecked();
|
|
Info.GetReturnValue().Set(V8Result);
|
|
|
|
return;
|
|
}
|
|
}
|
|
PUERTS_NAMESPACE::DataTransfer::ThrowException(Isolate, "Invalid argument!");
|
|
}
|
|
|
|
static void FQuatM_InitFromString(const v8::FunctionCallbackInfo<v8::Value>& Info)
|
|
{
|
|
v8::Isolate* Isolate = Info.GetIsolate();
|
|
v8::Local<v8::Context> Context = Isolate->GetCurrentContext();
|
|
if (Info.Length() == 1)
|
|
{
|
|
if (Info[0]->IsString())
|
|
{
|
|
const FString Arg0 = UTF8_TO_TCHAR(*(v8::String::Utf8Value(Isolate, Info[0])));
|
|
auto Self = PUERTS_NAMESPACE::DataTransfer::GetPointerFast<FQuat>(Info.Holder());
|
|
if (!Self)
|
|
{
|
|
PUERTS_NAMESPACE::DataTransfer::ThrowException(
|
|
Isolate, "[FQuat::M_InitFromString] Attempt to access a NULL self pointer");
|
|
return;
|
|
}
|
|
auto MethodResult = Self->InitFromString(Arg0);
|
|
auto V8Result = v8::Boolean::New(Isolate, MethodResult);
|
|
Info.GetReturnValue().Set(V8Result);
|
|
|
|
return;
|
|
}
|
|
}
|
|
PUERTS_NAMESPACE::DataTransfer::ThrowException(Isolate, "Invalid argument!");
|
|
}
|
|
|
|
static void FQuatM_DiagnosticCheckNaN(const v8::FunctionCallbackInfo<v8::Value>& Info)
|
|
{
|
|
v8::Isolate* Isolate = Info.GetIsolate();
|
|
v8::Local<v8::Context> Context = Isolate->GetCurrentContext();
|
|
if (Info.Length() == 0)
|
|
{
|
|
if (true)
|
|
{
|
|
auto Self = PUERTS_NAMESPACE::DataTransfer::GetPointerFast<FQuat>(Info.Holder());
|
|
if (!Self)
|
|
{
|
|
PUERTS_NAMESPACE::DataTransfer::ThrowException(
|
|
Isolate, "[FQuat::M_DiagnosticCheckNaN] Attempt to access a NULL self pointer");
|
|
return;
|
|
}
|
|
Self->DiagnosticCheckNaN();
|
|
|
|
return;
|
|
}
|
|
}
|
|
PUERTS_NAMESPACE::DataTransfer::ThrowException(Isolate, "Invalid argument!");
|
|
}
|
|
|
|
static void FQuatS_FindBetween(const v8::FunctionCallbackInfo<v8::Value>& Info)
|
|
{
|
|
v8::Isolate* Isolate = Info.GetIsolate();
|
|
v8::Local<v8::Context> Context = Isolate->GetCurrentContext();
|
|
if (Info.Length() == 2)
|
|
{
|
|
if (Info[0]->IsObject() &&
|
|
|
|
PUERTS_NAMESPACE::DataTransfer::IsInstanceOf<FVector>(Isolate, Info[0]->ToObject(Context).ToLocalChecked()) &&
|
|
Info[1]->IsObject() &&
|
|
|
|
PUERTS_NAMESPACE::DataTransfer::IsInstanceOf<FVector>(Isolate, Info[1]->ToObject(Context).ToLocalChecked()))
|
|
{
|
|
const FVector* Arg0 =
|
|
PUERTS_NAMESPACE::DataTransfer::GetPointerFast<FVector>(Info[0]->ToObject(Context).ToLocalChecked());
|
|
const FVector* Arg1 =
|
|
PUERTS_NAMESPACE::DataTransfer::GetPointerFast<FVector>(Info[1]->ToObject(Context).ToLocalChecked());
|
|
auto MethodResult = FQuat::FindBetween(*Arg0, *Arg1);
|
|
void* Ptr = new FQuat(MethodResult);
|
|
|
|
auto V8Result = PUERTS_NAMESPACE::DataTransfer::FindOrAddStruct<FQuat>(Isolate, Context, Ptr, false);
|
|
|
|
Info.GetReturnValue().Set(V8Result);
|
|
|
|
return;
|
|
}
|
|
}
|
|
PUERTS_NAMESPACE::DataTransfer::ThrowException(Isolate, "Invalid argument!");
|
|
}
|
|
|
|
static void FQuatS_FindBetweenNormals(const v8::FunctionCallbackInfo<v8::Value>& Info)
|
|
{
|
|
v8::Isolate* Isolate = Info.GetIsolate();
|
|
v8::Local<v8::Context> Context = Isolate->GetCurrentContext();
|
|
if (Info.Length() == 2)
|
|
{
|
|
if (Info[0]->IsObject() &&
|
|
|
|
PUERTS_NAMESPACE::DataTransfer::IsInstanceOf<FVector>(Isolate, Info[0]->ToObject(Context).ToLocalChecked()) &&
|
|
Info[1]->IsObject() &&
|
|
|
|
PUERTS_NAMESPACE::DataTransfer::IsInstanceOf<FVector>(Isolate, Info[1]->ToObject(Context).ToLocalChecked()))
|
|
{
|
|
const FVector* Arg0 =
|
|
PUERTS_NAMESPACE::DataTransfer::GetPointerFast<FVector>(Info[0]->ToObject(Context).ToLocalChecked());
|
|
const FVector* Arg1 =
|
|
PUERTS_NAMESPACE::DataTransfer::GetPointerFast<FVector>(Info[1]->ToObject(Context).ToLocalChecked());
|
|
auto MethodResult = FQuat::FindBetweenNormals(*Arg0, *Arg1);
|
|
void* Ptr = new FQuat(MethodResult);
|
|
|
|
auto V8Result = PUERTS_NAMESPACE::DataTransfer::FindOrAddStruct<FQuat>(Isolate, Context, Ptr, false);
|
|
|
|
Info.GetReturnValue().Set(V8Result);
|
|
|
|
return;
|
|
}
|
|
}
|
|
PUERTS_NAMESPACE::DataTransfer::ThrowException(Isolate, "Invalid argument!");
|
|
}
|
|
|
|
static void FQuatS_FindBetweenVectors(const v8::FunctionCallbackInfo<v8::Value>& Info)
|
|
{
|
|
v8::Isolate* Isolate = Info.GetIsolate();
|
|
v8::Local<v8::Context> Context = Isolate->GetCurrentContext();
|
|
if (Info.Length() == 2)
|
|
{
|
|
if (Info[0]->IsObject() &&
|
|
|
|
PUERTS_NAMESPACE::DataTransfer::IsInstanceOf<FVector>(Isolate, Info[0]->ToObject(Context).ToLocalChecked()) &&
|
|
Info[1]->IsObject() &&
|
|
|
|
PUERTS_NAMESPACE::DataTransfer::IsInstanceOf<FVector>(Isolate, Info[1]->ToObject(Context).ToLocalChecked()))
|
|
{
|
|
const FVector* Arg0 =
|
|
PUERTS_NAMESPACE::DataTransfer::GetPointerFast<FVector>(Info[0]->ToObject(Context).ToLocalChecked());
|
|
const FVector* Arg1 =
|
|
PUERTS_NAMESPACE::DataTransfer::GetPointerFast<FVector>(Info[1]->ToObject(Context).ToLocalChecked());
|
|
auto MethodResult = FQuat::FindBetweenVectors(*Arg0, *Arg1);
|
|
void* Ptr = new FQuat(MethodResult);
|
|
|
|
auto V8Result = PUERTS_NAMESPACE::DataTransfer::FindOrAddStruct<FQuat>(Isolate, Context, Ptr, false);
|
|
|
|
Info.GetReturnValue().Set(V8Result);
|
|
|
|
return;
|
|
}
|
|
}
|
|
PUERTS_NAMESPACE::DataTransfer::ThrowException(Isolate, "Invalid argument!");
|
|
}
|
|
|
|
static void FQuatS_Error(const v8::FunctionCallbackInfo<v8::Value>& Info)
|
|
{
|
|
v8::Isolate* Isolate = Info.GetIsolate();
|
|
v8::Local<v8::Context> Context = Isolate->GetCurrentContext();
|
|
if (Info.Length() == 2)
|
|
{
|
|
if (Info[0]->IsObject() &&
|
|
|
|
PUERTS_NAMESPACE::DataTransfer::IsInstanceOf<FQuat>(Isolate, Info[0]->ToObject(Context).ToLocalChecked()) &&
|
|
Info[1]->IsObject() &&
|
|
|
|
PUERTS_NAMESPACE::DataTransfer::IsInstanceOf<FQuat>(Isolate, Info[1]->ToObject(Context).ToLocalChecked()))
|
|
{
|
|
const FQuat* Arg0 = PUERTS_NAMESPACE::DataTransfer::GetPointerFast<FQuat>(Info[0]->ToObject(Context).ToLocalChecked());
|
|
const FQuat* Arg1 = PUERTS_NAMESPACE::DataTransfer::GetPointerFast<FQuat>(Info[1]->ToObject(Context).ToLocalChecked());
|
|
auto MethodResult = FQuat::Error(*Arg0, *Arg1);
|
|
auto V8Result = v8::Number::New(Isolate, MethodResult);
|
|
Info.GetReturnValue().Set(V8Result);
|
|
|
|
return;
|
|
}
|
|
}
|
|
PUERTS_NAMESPACE::DataTransfer::ThrowException(Isolate, "Invalid argument!");
|
|
}
|
|
|
|
static void FQuatS_ErrorAutoNormalize(const v8::FunctionCallbackInfo<v8::Value>& Info)
|
|
{
|
|
v8::Isolate* Isolate = Info.GetIsolate();
|
|
v8::Local<v8::Context> Context = Isolate->GetCurrentContext();
|
|
if (Info.Length() == 2)
|
|
{
|
|
if (Info[0]->IsObject() &&
|
|
|
|
PUERTS_NAMESPACE::DataTransfer::IsInstanceOf<FQuat>(Isolate, Info[0]->ToObject(Context).ToLocalChecked()) &&
|
|
Info[1]->IsObject() &&
|
|
|
|
PUERTS_NAMESPACE::DataTransfer::IsInstanceOf<FQuat>(Isolate, Info[1]->ToObject(Context).ToLocalChecked()))
|
|
{
|
|
const FQuat* Arg0 = PUERTS_NAMESPACE::DataTransfer::GetPointerFast<FQuat>(Info[0]->ToObject(Context).ToLocalChecked());
|
|
const FQuat* Arg1 = PUERTS_NAMESPACE::DataTransfer::GetPointerFast<FQuat>(Info[1]->ToObject(Context).ToLocalChecked());
|
|
auto MethodResult = FQuat::ErrorAutoNormalize(*Arg0, *Arg1);
|
|
auto V8Result = v8::Number::New(Isolate, MethodResult);
|
|
Info.GetReturnValue().Set(V8Result);
|
|
|
|
return;
|
|
}
|
|
}
|
|
PUERTS_NAMESPACE::DataTransfer::ThrowException(Isolate, "Invalid argument!");
|
|
}
|
|
|
|
static void FQuatS_FastLerp(const v8::FunctionCallbackInfo<v8::Value>& Info)
|
|
{
|
|
v8::Isolate* Isolate = Info.GetIsolate();
|
|
v8::Local<v8::Context> Context = Isolate->GetCurrentContext();
|
|
if (Info.Length() == 3)
|
|
{
|
|
if (Info[0]->IsObject() &&
|
|
|
|
PUERTS_NAMESPACE::DataTransfer::IsInstanceOf<FQuat>(Isolate, Info[0]->ToObject(Context).ToLocalChecked()) &&
|
|
Info[1]->IsObject() &&
|
|
|
|
PUERTS_NAMESPACE::DataTransfer::IsInstanceOf<FQuat>(Isolate, Info[1]->ToObject(Context).ToLocalChecked()) &&
|
|
Info[2]->IsNumber())
|
|
{
|
|
const FQuat* Arg0 = PUERTS_NAMESPACE::DataTransfer::GetPointerFast<FQuat>(Info[0]->ToObject(Context).ToLocalChecked());
|
|
const FQuat* Arg1 = PUERTS_NAMESPACE::DataTransfer::GetPointerFast<FQuat>(Info[1]->ToObject(Context).ToLocalChecked());
|
|
const float Arg2 = Info[2]->ToNumber(Context).ToLocalChecked()->Value();
|
|
auto MethodResult = FQuat::FastLerp(*Arg0, *Arg1, Arg2);
|
|
void* Ptr = new FQuat(MethodResult);
|
|
|
|
auto V8Result = PUERTS_NAMESPACE::DataTransfer::FindOrAddStruct<FQuat>(Isolate, Context, Ptr, false);
|
|
|
|
Info.GetReturnValue().Set(V8Result);
|
|
|
|
return;
|
|
}
|
|
}
|
|
PUERTS_NAMESPACE::DataTransfer::ThrowException(Isolate, "Invalid argument!");
|
|
}
|
|
|
|
static void FQuatS_FastBilerp(const v8::FunctionCallbackInfo<v8::Value>& Info)
|
|
{
|
|
v8::Isolate* Isolate = Info.GetIsolate();
|
|
v8::Local<v8::Context> Context = Isolate->GetCurrentContext();
|
|
if (Info.Length() == 6)
|
|
{
|
|
if (Info[0]->IsObject() &&
|
|
|
|
PUERTS_NAMESPACE::DataTransfer::IsInstanceOf<FQuat>(Isolate, Info[0]->ToObject(Context).ToLocalChecked()) &&
|
|
Info[1]->IsObject() &&
|
|
|
|
PUERTS_NAMESPACE::DataTransfer::IsInstanceOf<FQuat>(Isolate, Info[1]->ToObject(Context).ToLocalChecked()) &&
|
|
Info[2]->IsObject() &&
|
|
|
|
PUERTS_NAMESPACE::DataTransfer::IsInstanceOf<FQuat>(Isolate, Info[2]->ToObject(Context).ToLocalChecked()) &&
|
|
Info[3]->IsObject() &&
|
|
|
|
PUERTS_NAMESPACE::DataTransfer::IsInstanceOf<FQuat>(Isolate, Info[3]->ToObject(Context).ToLocalChecked()) &&
|
|
Info[4]->IsNumber() && Info[5]->IsNumber())
|
|
{
|
|
const FQuat* Arg0 = PUERTS_NAMESPACE::DataTransfer::GetPointerFast<FQuat>(Info[0]->ToObject(Context).ToLocalChecked());
|
|
const FQuat* Arg1 = PUERTS_NAMESPACE::DataTransfer::GetPointerFast<FQuat>(Info[1]->ToObject(Context).ToLocalChecked());
|
|
const FQuat* Arg2 = PUERTS_NAMESPACE::DataTransfer::GetPointerFast<FQuat>(Info[2]->ToObject(Context).ToLocalChecked());
|
|
const FQuat* Arg3 = PUERTS_NAMESPACE::DataTransfer::GetPointerFast<FQuat>(Info[3]->ToObject(Context).ToLocalChecked());
|
|
float Arg4 = Info[4]->ToNumber(Context).ToLocalChecked()->Value();
|
|
float Arg5 = Info[5]->ToNumber(Context).ToLocalChecked()->Value();
|
|
auto MethodResult = FQuat::FastBilerp(*Arg0, *Arg1, *Arg2, *Arg3, Arg4, Arg5);
|
|
void* Ptr = new FQuat(MethodResult);
|
|
|
|
auto V8Result = PUERTS_NAMESPACE::DataTransfer::FindOrAddStruct<FQuat>(Isolate, Context, Ptr, false);
|
|
|
|
Info.GetReturnValue().Set(V8Result);
|
|
|
|
return;
|
|
}
|
|
}
|
|
PUERTS_NAMESPACE::DataTransfer::ThrowException(Isolate, "Invalid argument!");
|
|
}
|
|
|
|
static void FQuatS_Slerp_NotNormalized(const v8::FunctionCallbackInfo<v8::Value>& Info)
|
|
{
|
|
v8::Isolate* Isolate = Info.GetIsolate();
|
|
v8::Local<v8::Context> Context = Isolate->GetCurrentContext();
|
|
if (Info.Length() == 3)
|
|
{
|
|
if (Info[0]->IsObject() &&
|
|
|
|
PUERTS_NAMESPACE::DataTransfer::IsInstanceOf<FQuat>(Isolate, Info[0]->ToObject(Context).ToLocalChecked()) &&
|
|
Info[1]->IsObject() &&
|
|
|
|
PUERTS_NAMESPACE::DataTransfer::IsInstanceOf<FQuat>(Isolate, Info[1]->ToObject(Context).ToLocalChecked()) &&
|
|
Info[2]->IsNumber())
|
|
{
|
|
const FQuat* Arg0 = PUERTS_NAMESPACE::DataTransfer::GetPointerFast<FQuat>(Info[0]->ToObject(Context).ToLocalChecked());
|
|
const FQuat* Arg1 = PUERTS_NAMESPACE::DataTransfer::GetPointerFast<FQuat>(Info[1]->ToObject(Context).ToLocalChecked());
|
|
float Arg2 = Info[2]->ToNumber(Context).ToLocalChecked()->Value();
|
|
auto MethodResult = FQuat::Slerp_NotNormalized(*Arg0, *Arg1, Arg2);
|
|
void* Ptr = new FQuat(MethodResult);
|
|
|
|
auto V8Result = PUERTS_NAMESPACE::DataTransfer::FindOrAddStruct<FQuat>(Isolate, Context, Ptr, false);
|
|
|
|
Info.GetReturnValue().Set(V8Result);
|
|
|
|
return;
|
|
}
|
|
}
|
|
PUERTS_NAMESPACE::DataTransfer::ThrowException(Isolate, "Invalid argument!");
|
|
}
|
|
|
|
static void FQuatS_Slerp(const v8::FunctionCallbackInfo<v8::Value>& Info)
|
|
{
|
|
v8::Isolate* Isolate = Info.GetIsolate();
|
|
v8::Local<v8::Context> Context = Isolate->GetCurrentContext();
|
|
if (Info.Length() == 3)
|
|
{
|
|
if (Info[0]->IsObject() &&
|
|
|
|
PUERTS_NAMESPACE::DataTransfer::IsInstanceOf<FQuat>(Isolate, Info[0]->ToObject(Context).ToLocalChecked()) &&
|
|
Info[1]->IsObject() &&
|
|
|
|
PUERTS_NAMESPACE::DataTransfer::IsInstanceOf<FQuat>(Isolate, Info[1]->ToObject(Context).ToLocalChecked()) &&
|
|
Info[2]->IsNumber())
|
|
{
|
|
const FQuat* Arg0 = PUERTS_NAMESPACE::DataTransfer::GetPointerFast<FQuat>(Info[0]->ToObject(Context).ToLocalChecked());
|
|
const FQuat* Arg1 = PUERTS_NAMESPACE::DataTransfer::GetPointerFast<FQuat>(Info[1]->ToObject(Context).ToLocalChecked());
|
|
float Arg2 = Info[2]->ToNumber(Context).ToLocalChecked()->Value();
|
|
auto MethodResult = FQuat::Slerp(*Arg0, *Arg1, Arg2);
|
|
void* Ptr = new FQuat(MethodResult);
|
|
|
|
auto V8Result = PUERTS_NAMESPACE::DataTransfer::FindOrAddStruct<FQuat>(Isolate, Context, Ptr, false);
|
|
|
|
Info.GetReturnValue().Set(V8Result);
|
|
|
|
return;
|
|
}
|
|
}
|
|
PUERTS_NAMESPACE::DataTransfer::ThrowException(Isolate, "Invalid argument!");
|
|
}
|
|
|
|
static void FQuatS_SlerpFullPath_NotNormalized(const v8::FunctionCallbackInfo<v8::Value>& Info)
|
|
{
|
|
v8::Isolate* Isolate = Info.GetIsolate();
|
|
v8::Local<v8::Context> Context = Isolate->GetCurrentContext();
|
|
if (Info.Length() == 3)
|
|
{
|
|
if (Info[0]->IsObject() &&
|
|
|
|
PUERTS_NAMESPACE::DataTransfer::IsInstanceOf<FQuat>(Isolate, Info[0]->ToObject(Context).ToLocalChecked()) &&
|
|
Info[1]->IsObject() &&
|
|
|
|
PUERTS_NAMESPACE::DataTransfer::IsInstanceOf<FQuat>(Isolate, Info[1]->ToObject(Context).ToLocalChecked()) &&
|
|
Info[2]->IsNumber())
|
|
{
|
|
const FQuat* Arg0 = PUERTS_NAMESPACE::DataTransfer::GetPointerFast<FQuat>(Info[0]->ToObject(Context).ToLocalChecked());
|
|
const FQuat* Arg1 = PUERTS_NAMESPACE::DataTransfer::GetPointerFast<FQuat>(Info[1]->ToObject(Context).ToLocalChecked());
|
|
float Arg2 = Info[2]->ToNumber(Context).ToLocalChecked()->Value();
|
|
auto MethodResult = FQuat::SlerpFullPath_NotNormalized(*Arg0, *Arg1, Arg2);
|
|
void* Ptr = new FQuat(MethodResult);
|
|
|
|
auto V8Result = PUERTS_NAMESPACE::DataTransfer::FindOrAddStruct<FQuat>(Isolate, Context, Ptr, false);
|
|
|
|
Info.GetReturnValue().Set(V8Result);
|
|
|
|
return;
|
|
}
|
|
}
|
|
PUERTS_NAMESPACE::DataTransfer::ThrowException(Isolate, "Invalid argument!");
|
|
}
|
|
|
|
static void FQuatS_SlerpFullPath(const v8::FunctionCallbackInfo<v8::Value>& Info)
|
|
{
|
|
v8::Isolate* Isolate = Info.GetIsolate();
|
|
v8::Local<v8::Context> Context = Isolate->GetCurrentContext();
|
|
if (Info.Length() == 3)
|
|
{
|
|
if (Info[0]->IsObject() &&
|
|
|
|
PUERTS_NAMESPACE::DataTransfer::IsInstanceOf<FQuat>(Isolate, Info[0]->ToObject(Context).ToLocalChecked()) &&
|
|
Info[1]->IsObject() &&
|
|
|
|
PUERTS_NAMESPACE::DataTransfer::IsInstanceOf<FQuat>(Isolate, Info[1]->ToObject(Context).ToLocalChecked()) &&
|
|
Info[2]->IsNumber())
|
|
{
|
|
const FQuat* Arg0 = PUERTS_NAMESPACE::DataTransfer::GetPointerFast<FQuat>(Info[0]->ToObject(Context).ToLocalChecked());
|
|
const FQuat* Arg1 = PUERTS_NAMESPACE::DataTransfer::GetPointerFast<FQuat>(Info[1]->ToObject(Context).ToLocalChecked());
|
|
float Arg2 = Info[2]->ToNumber(Context).ToLocalChecked()->Value();
|
|
auto MethodResult = FQuat::SlerpFullPath(*Arg0, *Arg1, Arg2);
|
|
void* Ptr = new FQuat(MethodResult);
|
|
|
|
auto V8Result = PUERTS_NAMESPACE::DataTransfer::FindOrAddStruct<FQuat>(Isolate, Context, Ptr, false);
|
|
|
|
Info.GetReturnValue().Set(V8Result);
|
|
|
|
return;
|
|
}
|
|
}
|
|
PUERTS_NAMESPACE::DataTransfer::ThrowException(Isolate, "Invalid argument!");
|
|
}
|
|
|
|
static void FQuatS_Squad(const v8::FunctionCallbackInfo<v8::Value>& Info)
|
|
{
|
|
v8::Isolate* Isolate = Info.GetIsolate();
|
|
v8::Local<v8::Context> Context = Isolate->GetCurrentContext();
|
|
if (Info.Length() == 5)
|
|
{
|
|
if (Info[0]->IsObject() &&
|
|
|
|
PUERTS_NAMESPACE::DataTransfer::IsInstanceOf<FQuat>(Isolate, Info[0]->ToObject(Context).ToLocalChecked()) &&
|
|
Info[1]->IsObject() &&
|
|
|
|
PUERTS_NAMESPACE::DataTransfer::IsInstanceOf<FQuat>(Isolate, Info[1]->ToObject(Context).ToLocalChecked()) &&
|
|
Info[2]->IsObject() &&
|
|
|
|
PUERTS_NAMESPACE::DataTransfer::IsInstanceOf<FQuat>(Isolate, Info[2]->ToObject(Context).ToLocalChecked()) &&
|
|
Info[3]->IsObject() &&
|
|
|
|
PUERTS_NAMESPACE::DataTransfer::IsInstanceOf<FQuat>(Isolate, Info[3]->ToObject(Context).ToLocalChecked()) &&
|
|
Info[4]->IsNumber())
|
|
{
|
|
const FQuat* Arg0 = PUERTS_NAMESPACE::DataTransfer::GetPointerFast<FQuat>(Info[0]->ToObject(Context).ToLocalChecked());
|
|
const FQuat* Arg1 = PUERTS_NAMESPACE::DataTransfer::GetPointerFast<FQuat>(Info[1]->ToObject(Context).ToLocalChecked());
|
|
const FQuat* Arg2 = PUERTS_NAMESPACE::DataTransfer::GetPointerFast<FQuat>(Info[2]->ToObject(Context).ToLocalChecked());
|
|
const FQuat* Arg3 = PUERTS_NAMESPACE::DataTransfer::GetPointerFast<FQuat>(Info[3]->ToObject(Context).ToLocalChecked());
|
|
float Arg4 = Info[4]->ToNumber(Context).ToLocalChecked()->Value();
|
|
auto MethodResult = FQuat::Squad(*Arg0, *Arg1, *Arg2, *Arg3, Arg4);
|
|
void* Ptr = new FQuat(MethodResult);
|
|
|
|
auto V8Result = PUERTS_NAMESPACE::DataTransfer::FindOrAddStruct<FQuat>(Isolate, Context, Ptr, false);
|
|
|
|
Info.GetReturnValue().Set(V8Result);
|
|
|
|
return;
|
|
}
|
|
}
|
|
PUERTS_NAMESPACE::DataTransfer::ThrowException(Isolate, "Invalid argument!");
|
|
}
|
|
|
|
static void FQuatS_SquadFullPath(const v8::FunctionCallbackInfo<v8::Value>& Info)
|
|
{
|
|
v8::Isolate* Isolate = Info.GetIsolate();
|
|
v8::Local<v8::Context> Context = Isolate->GetCurrentContext();
|
|
if (Info.Length() == 5)
|
|
{
|
|
if (Info[0]->IsObject() &&
|
|
|
|
PUERTS_NAMESPACE::DataTransfer::IsInstanceOf<FQuat>(Isolate, Info[0]->ToObject(Context).ToLocalChecked()) &&
|
|
Info[1]->IsObject() &&
|
|
|
|
PUERTS_NAMESPACE::DataTransfer::IsInstanceOf<FQuat>(Isolate, Info[1]->ToObject(Context).ToLocalChecked()) &&
|
|
Info[2]->IsObject() &&
|
|
|
|
PUERTS_NAMESPACE::DataTransfer::IsInstanceOf<FQuat>(Isolate, Info[2]->ToObject(Context).ToLocalChecked()) &&
|
|
Info[3]->IsObject() &&
|
|
|
|
PUERTS_NAMESPACE::DataTransfer::IsInstanceOf<FQuat>(Isolate, Info[3]->ToObject(Context).ToLocalChecked()) &&
|
|
Info[4]->IsNumber())
|
|
{
|
|
const FQuat* Arg0 = PUERTS_NAMESPACE::DataTransfer::GetPointerFast<FQuat>(Info[0]->ToObject(Context).ToLocalChecked());
|
|
const FQuat* Arg1 = PUERTS_NAMESPACE::DataTransfer::GetPointerFast<FQuat>(Info[1]->ToObject(Context).ToLocalChecked());
|
|
const FQuat* Arg2 = PUERTS_NAMESPACE::DataTransfer::GetPointerFast<FQuat>(Info[2]->ToObject(Context).ToLocalChecked());
|
|
const FQuat* Arg3 = PUERTS_NAMESPACE::DataTransfer::GetPointerFast<FQuat>(Info[3]->ToObject(Context).ToLocalChecked());
|
|
float Arg4 = Info[4]->ToNumber(Context).ToLocalChecked()->Value();
|
|
auto MethodResult = FQuat::SquadFullPath(*Arg0, *Arg1, *Arg2, *Arg3, Arg4);
|
|
void* Ptr = new FQuat(MethodResult);
|
|
|
|
auto V8Result = PUERTS_NAMESPACE::DataTransfer::FindOrAddStruct<FQuat>(Isolate, Context, Ptr, false);
|
|
|
|
Info.GetReturnValue().Set(V8Result);
|
|
|
|
return;
|
|
}
|
|
}
|
|
PUERTS_NAMESPACE::DataTransfer::ThrowException(Isolate, "Invalid argument!");
|
|
}
|
|
|
|
static void FQuatS_CalcTangents(const v8::FunctionCallbackInfo<v8::Value>& Info)
|
|
{
|
|
v8::Isolate* Isolate = Info.GetIsolate();
|
|
v8::Local<v8::Context> Context = Isolate->GetCurrentContext();
|
|
if (Info.Length() == 5)
|
|
{
|
|
if (Info[0]->IsObject() &&
|
|
|
|
PUERTS_NAMESPACE::DataTransfer::IsInstanceOf<FQuat>(Isolate, Info[0]->ToObject(Context).ToLocalChecked()) &&
|
|
Info[1]->IsObject() &&
|
|
|
|
PUERTS_NAMESPACE::DataTransfer::IsInstanceOf<FQuat>(Isolate, Info[1]->ToObject(Context).ToLocalChecked()) &&
|
|
Info[2]->IsObject() &&
|
|
|
|
PUERTS_NAMESPACE::DataTransfer::IsInstanceOf<FQuat>(Isolate, Info[2]->ToObject(Context).ToLocalChecked()) &&
|
|
Info[3]->IsNumber() && Info[4]->IsObject() && PUERTS_NAMESPACE::DataTransfer::UnRef(Isolate, Info[4])->IsObject() &&
|
|
|
|
PUERTS_NAMESPACE::DataTransfer::IsInstanceOf<FQuat>(
|
|
Isolate, PUERTS_NAMESPACE::DataTransfer::UnRef(Isolate, Info[4])->ToObject(Context).ToLocalChecked()))
|
|
{
|
|
const FQuat* Arg0 = PUERTS_NAMESPACE::DataTransfer::GetPointerFast<FQuat>(Info[0]->ToObject(Context).ToLocalChecked());
|
|
const FQuat* Arg1 = PUERTS_NAMESPACE::DataTransfer::GetPointerFast<FQuat>(Info[1]->ToObject(Context).ToLocalChecked());
|
|
const FQuat* Arg2 = PUERTS_NAMESPACE::DataTransfer::GetPointerFast<FQuat>(Info[2]->ToObject(Context).ToLocalChecked());
|
|
float Arg3 = Info[3]->ToNumber(Context).ToLocalChecked()->Value();
|
|
FQuat* Arg4 = PUERTS_NAMESPACE::DataTransfer::GetPointerFast<FQuat>(
|
|
PUERTS_NAMESPACE::DataTransfer::UnRef(Isolate, Info[4])->ToObject(Context).ToLocalChecked());
|
|
FQuat::CalcTangents(*Arg0, *Arg1, *Arg2, Arg3, *Arg4);
|
|
|
|
return;
|
|
}
|
|
}
|
|
PUERTS_NAMESPACE::DataTransfer::ThrowException(Isolate, "Invalid argument!");
|
|
}
|
|
|
|
static void _FQuatXGet_(const v8::FunctionCallbackInfo<v8::Value>& Info)
|
|
{
|
|
v8::Isolate* Isolate = Info.GetIsolate();
|
|
v8::Local<v8::Context> Context = Isolate->GetCurrentContext();
|
|
|
|
auto Self = PUERTS_NAMESPACE::DataTransfer::GetPointerFast<FQuat>(Info.Holder());
|
|
|
|
if (!Self)
|
|
{
|
|
PUERTS_NAMESPACE::DataTransfer::ThrowException(Isolate, "[FQuat::X] Attempt to access a NULL self pointer");
|
|
return;
|
|
}
|
|
|
|
auto V8Result = v8::Number::New(Isolate, Self->X);
|
|
PUERTS_NAMESPACE::DataTransfer::LinkOuter<FQuat, float>(Context, Info.Holder(), V8Result);
|
|
Info.GetReturnValue().Set(V8Result);
|
|
}
|
|
static void _FQuatXSet_(const v8::FunctionCallbackInfo<v8::Value>& Info)
|
|
{
|
|
v8::Isolate* Isolate = Info.GetIsolate();
|
|
v8::Local<v8::Context> Context = Isolate->GetCurrentContext();
|
|
|
|
auto Self = PUERTS_NAMESPACE::DataTransfer::GetPointerFast<FQuat>(Info.Holder());
|
|
if (!Self)
|
|
{
|
|
PUERTS_NAMESPACE::DataTransfer::ThrowException(Isolate, "[FQuat::X] Attempt to access a NULL self pointer");
|
|
return;
|
|
}
|
|
auto Value = Info[0];
|
|
|
|
Self->X = Value->ToNumber(Context).ToLocalChecked()->Value();
|
|
}
|
|
static void _FQuatYGet_(const v8::FunctionCallbackInfo<v8::Value>& Info)
|
|
{
|
|
v8::Isolate* Isolate = Info.GetIsolate();
|
|
v8::Local<v8::Context> Context = Isolate->GetCurrentContext();
|
|
|
|
auto Self = PUERTS_NAMESPACE::DataTransfer::GetPointerFast<FQuat>(Info.Holder());
|
|
|
|
if (!Self)
|
|
{
|
|
PUERTS_NAMESPACE::DataTransfer::ThrowException(Isolate, "[FQuat::Y] Attempt to access a NULL self pointer");
|
|
return;
|
|
}
|
|
|
|
auto V8Result = v8::Number::New(Isolate, Self->Y);
|
|
PUERTS_NAMESPACE::DataTransfer::LinkOuter<FQuat, float>(Context, Info.Holder(), V8Result);
|
|
Info.GetReturnValue().Set(V8Result);
|
|
}
|
|
static void _FQuatYSet_(const v8::FunctionCallbackInfo<v8::Value>& Info)
|
|
{
|
|
v8::Isolate* Isolate = Info.GetIsolate();
|
|
v8::Local<v8::Context> Context = Isolate->GetCurrentContext();
|
|
|
|
auto Self = PUERTS_NAMESPACE::DataTransfer::GetPointerFast<FQuat>(Info.Holder());
|
|
if (!Self)
|
|
{
|
|
PUERTS_NAMESPACE::DataTransfer::ThrowException(Isolate, "[FQuat::Y] Attempt to access a NULL self pointer");
|
|
return;
|
|
}
|
|
auto Value = Info[0];
|
|
|
|
Self->Y = Value->ToNumber(Context).ToLocalChecked()->Value();
|
|
}
|
|
static void _FQuatZGet_(const v8::FunctionCallbackInfo<v8::Value>& Info)
|
|
{
|
|
v8::Isolate* Isolate = Info.GetIsolate();
|
|
v8::Local<v8::Context> Context = Isolate->GetCurrentContext();
|
|
|
|
auto Self = PUERTS_NAMESPACE::DataTransfer::GetPointerFast<FQuat>(Info.Holder());
|
|
|
|
if (!Self)
|
|
{
|
|
PUERTS_NAMESPACE::DataTransfer::ThrowException(Isolate, "[FQuat::Z] Attempt to access a NULL self pointer");
|
|
return;
|
|
}
|
|
|
|
auto V8Result = v8::Number::New(Isolate, Self->Z);
|
|
PUERTS_NAMESPACE::DataTransfer::LinkOuter<FQuat, float>(Context, Info.Holder(), V8Result);
|
|
Info.GetReturnValue().Set(V8Result);
|
|
}
|
|
static void _FQuatZSet_(const v8::FunctionCallbackInfo<v8::Value>& Info)
|
|
{
|
|
v8::Isolate* Isolate = Info.GetIsolate();
|
|
v8::Local<v8::Context> Context = Isolate->GetCurrentContext();
|
|
|
|
auto Self = PUERTS_NAMESPACE::DataTransfer::GetPointerFast<FQuat>(Info.Holder());
|
|
if (!Self)
|
|
{
|
|
PUERTS_NAMESPACE::DataTransfer::ThrowException(Isolate, "[FQuat::Z] Attempt to access a NULL self pointer");
|
|
return;
|
|
}
|
|
auto Value = Info[0];
|
|
|
|
Self->Z = Value->ToNumber(Context).ToLocalChecked()->Value();
|
|
}
|
|
static void _FQuatWGet_(const v8::FunctionCallbackInfo<v8::Value>& Info)
|
|
{
|
|
v8::Isolate* Isolate = Info.GetIsolate();
|
|
v8::Local<v8::Context> Context = Isolate->GetCurrentContext();
|
|
|
|
auto Self = PUERTS_NAMESPACE::DataTransfer::GetPointerFast<FQuat>(Info.Holder());
|
|
|
|
if (!Self)
|
|
{
|
|
PUERTS_NAMESPACE::DataTransfer::ThrowException(Isolate, "[FQuat::W] Attempt to access a NULL self pointer");
|
|
return;
|
|
}
|
|
|
|
auto V8Result = v8::Number::New(Isolate, Self->W);
|
|
PUERTS_NAMESPACE::DataTransfer::LinkOuter<FQuat, float>(Context, Info.Holder(), V8Result);
|
|
Info.GetReturnValue().Set(V8Result);
|
|
}
|
|
static void _FQuatWSet_(const v8::FunctionCallbackInfo<v8::Value>& Info)
|
|
{
|
|
v8::Isolate* Isolate = Info.GetIsolate();
|
|
v8::Local<v8::Context> Context = Isolate->GetCurrentContext();
|
|
|
|
auto Self = PUERTS_NAMESPACE::DataTransfer::GetPointerFast<FQuat>(Info.Holder());
|
|
if (!Self)
|
|
{
|
|
PUERTS_NAMESPACE::DataTransfer::ThrowException(Isolate, "[FQuat::W] Attempt to access a NULL self pointer");
|
|
return;
|
|
}
|
|
auto Value = Info[0];
|
|
|
|
Self->W = Value->ToNumber(Context).ToLocalChecked()->Value();
|
|
}
|
|
|
|
struct AutoRegisterForFQuat
|
|
{
|
|
AutoRegisterForFQuat()
|
|
{
|
|
PUERTS_NAMESPACE::JSClassDefinition Def = JSClassEmptyDefinition;
|
|
|
|
static PUERTS_NAMESPACE::JSPropertyInfo Properties[] = {{"X", _FQuatXGet_, _FQuatXSet_}, {"Y", _FQuatYGet_, _FQuatYSet_},
|
|
{"Z", _FQuatZGet_, _FQuatZSet_}, {"W", _FQuatWGet_, _FQuatWSet_}, {0, 0, 0}};
|
|
|
|
static PUERTS_NAMESPACE::JSFunctionInfo Methods[] = {{"op_Addition", FQuatM_op_Addition},
|
|
{"op_Subtraction", FQuatM_op_Subtraction}, {"Equals", FQuatM_Equals}, {"IsIdentity", FQuatM_IsIdentity},
|
|
{"op_Multiply", FQuatM_op_Multiply}, {"op_Division", FQuatM_op_Division}, {"op_Equality", FQuatM_op_Equality},
|
|
{"op_Inequality", FQuatM_op_Inequality}, {"op_BitwiseOr", FQuatM_op_BitwiseOr}, {"Euler", FQuatM_Euler},
|
|
{"Normalize", FQuatM_Normalize}, {"GetNormalized", FQuatM_GetNormalized}, {"IsNormalized", FQuatM_IsNormalized},
|
|
{"Size", FQuatM_Size}, {"SizeSquared", FQuatM_SizeSquared}, {"GetAngle", FQuatM_GetAngle},
|
|
{"ToAxisAndAngle", FQuatM_ToAxisAndAngle}, {"ToSwingTwist", FQuatM_ToSwingTwist}, {"RotateVector", FQuatM_RotateVector},
|
|
{"UnrotateVector", FQuatM_UnrotateVector}, {"Log", FQuatM_Log}, {"Exp", FQuatM_Exp}, {"Inverse", FQuatM_Inverse},
|
|
{"EnforceShortestArcWith", FQuatM_EnforceShortestArcWith}, {"GetAxisX", FQuatM_GetAxisX}, {"GetAxisY", FQuatM_GetAxisY},
|
|
{"GetAxisZ", FQuatM_GetAxisZ}, {"GetForwardVector", FQuatM_GetForwardVector}, {"GetRightVector", FQuatM_GetRightVector},
|
|
{"GetUpVector", FQuatM_GetUpVector}, {"Vector", FQuatM_Vector}, {"Rotator", FQuatM_Rotator},
|
|
{"GetRotationAxis", FQuatM_GetRotationAxis}, {"AngularDistance", FQuatM_AngularDistance},
|
|
{"ContainsNaN", FQuatM_ContainsNaN}, {"ToString", FQuatM_ToString}, {"InitFromString", FQuatM_InitFromString},
|
|
{"DiagnosticCheckNaN", FQuatM_DiagnosticCheckNaN}, {0, 0}};
|
|
|
|
static PUERTS_NAMESPACE::JSFunctionInfo Functions[] = {{"MakeFromEuler", FQuatS_MakeFromEuler},
|
|
{"FindBetween", FQuatS_FindBetween}, {"FindBetweenNormals", FQuatS_FindBetweenNormals},
|
|
{"FindBetweenVectors", FQuatS_FindBetweenVectors}, {"Error", FQuatS_Error},
|
|
{"ErrorAutoNormalize", FQuatS_ErrorAutoNormalize}, {"FastLerp", FQuatS_FastLerp}, {"FastBilerp", FQuatS_FastBilerp},
|
|
{"Slerp_NotNormalized", FQuatS_Slerp_NotNormalized}, {"Slerp", FQuatS_Slerp},
|
|
{"SlerpFullPath_NotNormalized", FQuatS_SlerpFullPath_NotNormalized}, {"SlerpFullPath", FQuatS_SlerpFullPath},
|
|
{"Squad", FQuatS_Squad}, {"SquadFullPath", FQuatS_SquadFullPath}, {"CalcTangents", FQuatS_CalcTangents}, {0, 0}};
|
|
|
|
Def.UETypeName = "Quat";
|
|
|
|
Def.SetInitialize(_FQuatNew_);
|
|
Def.Finalize = _FQuatDelete_;
|
|
Def.Properties = Properties;
|
|
Def.Methods = Methods;
|
|
Def.Functions = Functions;
|
|
|
|
PUERTS_NAMESPACE::RegisterJSClass(Def);
|
|
}
|
|
};
|
|
|
|
AutoRegisterForFQuat _AutoRegisterForFQuat_; |