starmen1265/AncientCivil
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
d79dbe71dc76ad90b4eddbb3dbdc7e5b692fd3cf
AncientCivil/Plugins/Puerts/Source/JsEnv/Private/JsEnvImpl.cpp
T
starmen1265 1e0c4b8d8c Init
2025-02-10 00:44:11 +08:00

4814 lines
172 KiB
C++
Raw Blame History

/*
* 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.
*/
#include "JsEnvImpl.h"
#include "JsEnvModule.h"
#include "DynamicDelegateProxy.h"
#include "Misc/FileHelper.h"
#include "Misc/Paths.h"
#include "StructWrapper.h"
#include "DelegateWrapper.h"
#include "ContainerWrapper.h"
#include "SoftObjectWrapper.h"
#include "V8Utils.h"
#include "ObjectMapper.h"
#include "JSLogger.h"
#if !defined(ENGINE_INDEPENDENT_JSENV)
#include "JSGeneratedClass.h"
#include "JSAnimGeneratedClass.h"
#include "JSWidgetGeneratedClass.h"
#include "JSGeneratedFunction.h"
#endif
#include "JSClassRegister.h"
#include "PromiseRejectCallback.hpp"
#if !defined(ENGINE_INDEPENDENT_JSENV)
#include "TypeScriptGeneratedClass.h"
#include "Engine/UserDefinedEnum.h"
#endif
#include "ContainerMeta.h"
#include "V8InspectorImpl.h"
#if USE_WASM3
#include "WasmModuleInstance.h"
#endif
#if !defined(WITH_NODEJS)
#if V8_MAJOR_VERSION < 8 && !defined(WITH_QUICKJS)
#if PLATFORM_WINDOWS
#include "Blob/Win64/NativesBlob.h"
#include "Blob/Win64/SnapshotBlob.h"
#elif PLATFORM_ANDROID_ARM
#include "Blob/Android/armv7a/NativesBlob.h"
#include "Blob/Android/armv7a/SnapshotBlob.h"
#elif PLATFORM_ANDROID_ARM64
#include "Blob/Android/arm64/NativesBlob.h"
#include "Blob/Android/arm64/SnapshotBlob.h"
#elif PLATFORM_MAC
#include "Blob/macOS/NativesBlob.h"
#include "Blob/macOS/SnapshotBlob.h"
#elif PLATFORM_IOS
#include "Blob/iOS/arm64/NativesBlob.h"
#include "Blob/iOS/arm64/SnapshotBlob.h"
#elif PLATFORM_LINUX
#include "Blob/Linux/NativesBlob.h"
#include "Blob/Linux/SnapshotBlob.h"
#endif
#endif
#else
PRAGMA_DISABLE_UNDEFINED_IDENTIFIER_WARNINGS
#if PLATFORM_WINDOWS
#include <windows.h>
#elif PLATFORM_LINUX
#include <sys/epoll.h>
#elif PLATFORM_MAC
#include <sys/select.h>
#include <sys/sysctl.h>
#include <sys/time.h>
#include <sys/types.h>
#endif
PRAGMA_ENABLE_UNDEFINED_IDENTIFIER_WARNINGS
#endif
#if !defined(ENGINE_INDEPENDENT_JSENV)
#include "Engine/CollisionProfile.h"
#endif
#if USE_WASM3
#include "PuertsWasm/WasmJsFunctionParams.h"
#endif
#if defined(WITH_WEBSOCKET)
void InitWebsocketPPWrap(v8::Local<v8::Context> Context);
#endif
namespace PUERTS_NAMESPACE
{
#if !defined(WITH_QUICKJS)
void LoadPesapiDll(const v8::FunctionCallbackInfo<v8::Value>& Info);
#endif
FJsEnvImpl::FJsEnvImpl(const FString& ScriptRoot)
: FJsEnvImpl(std::make_shared<DefaultJSModuleLoader>(ScriptRoot), std::make_shared<FDefaultLogger>(), -1, nullptr, FString(),
nullptr, nullptr)
{
}
static void FNameToArrayBuffer(const v8::FunctionCallbackInfo<v8::Value>& Info)
{
FName Name = FV8Utils::ToFName(Info.GetIsolate(), Info[0]);
v8::Local<v8::ArrayBuffer> Ab = v8::ArrayBuffer::New(Info.GetIsolate(), sizeof(FName));
void* Buff = DataTransfer::GetArrayBufferData(Ab);
::memcpy(Buff, &Name, sizeof(FName));
Info.GetReturnValue().Set(Ab);
}
static void ToCString(const v8::FunctionCallbackInfo<v8::Value>& Info)
{
auto Isolate = Info.GetIsolate();
if (!Info[0]->IsString())
{
FV8Utils::ThrowException(Isolate, "expect a string");
return;
}
v8::Local<v8::String> Str = Info[0]->ToString(Isolate->GetCurrentContext()).ToLocalChecked();
const size_t Length = Str->Utf8Length(Isolate);
v8::Local<v8::ArrayBuffer> Ab = v8::ArrayBuffer::New(Info.GetIsolate(), Length + 1);
char* Buff = static_cast<char*>(DataTransfer::GetArrayBufferData(Ab));
Str->WriteUtf8(Isolate, Buff);
Buff[Length] = '\0';
Info.GetReturnValue().Set(Ab);
}
static void ToCPtrArray(const v8::FunctionCallbackInfo<v8::Value>& Info)
{
const size_t Length = sizeof(void*) * Info.Length();
v8::Local<v8::ArrayBuffer> Ret = v8::ArrayBuffer::New(Info.GetIsolate(), Length);
void** Buff = static_cast<void**>(DataTransfer::GetArrayBufferData(Ret));
for (int i = 0; i < Info.Length(); i++)
{
auto Val = Info[i];
void* Ptr = nullptr;
if (Val->IsArrayBufferView())
{
v8::Local<v8::ArrayBufferView> BuffView = Val.As<v8::ArrayBufferView>();
auto Ab = BuffView->Buffer();
Ptr = static_cast<char*>(DataTransfer::GetArrayBufferData(Ab)) + BuffView->ByteOffset();
}
else if (Val->IsArrayBuffer())
{
auto Ab = v8::Local<v8::ArrayBuffer>::Cast(Val);
Ptr = static_cast<char*>(DataTransfer::GetArrayBufferData(Ab));
}
Buff[i] = Ptr;
}
Info.GetReturnValue().Set(Ret);
}
#if defined(WITH_NODEJS)
void FJsEnvImpl::StartPolling()
{
uv_async_init(&NodeUVLoop, &DummyUVHandle, nullptr);
uv_sem_init(&PollingSem, 0);
uv_thread_create(
&PollingThread,
[](void* arg)
{
auto* self = static_cast<FJsEnvImpl*>(arg);
while (true)
{
uv_sem_wait(&self->PollingSem);
if (self->PollingClosed)
break;
self->PollEvents();
if (self->PollingClosed)
break;
self->LastJob = FFunctionGraphTask::CreateAndDispatchWhenReady(
[self]() { self->UvRunOnce(); }, TStatId{}, nullptr, ENamedThreads::GameThread);
}
},
this);
#if PLATFORM_WINDOWS
// on single-core the io comp port NumberOfConcurrentThreads needs to be 2
// to avoid cpu pegging likely caused by a busy loop in PollEvents
if (FPlatformMisc::NumberOfCores() == 1)
{
if (NodeUVLoop.iocp && NodeUVLoop.iocp != INVALID_HANDLE_VALUE)
CloseHandle(NodeUVLoop.iocp);
NodeUVLoop.iocp = CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL, 0, 2);
}
#elif PLATFORM_LINUX
Epoll = epoll_create(1);
int backend_fd = uv_backend_fd(&NodeUVLoop);
struct epoll_event ev = {0};
ev.events = EPOLLIN;
ev.data.fd = backend_fd;
epoll_ctl(Epoll, EPOLL_CTL_ADD, backend_fd, &ev);
NodeUVLoop.data = this;
NodeUVLoop.on_watcher_queue_updated = OnWatcherQueueChanged;
#elif PLATFORM_MAC
NodeUVLoop.data = this;
NodeUVLoop.on_watcher_queue_updated = OnWatcherQueueChanged;
#endif
UvRunOnce();
}
void FJsEnvImpl::UvRunOnce()
{
auto Isolate = MainIsolate;
#ifdef THREAD_SAFE
v8::Locker Locker(Isolate);
#endif
v8::Isolate::Scope IsolateScope(Isolate);
v8::HandleScope HandleScope(Isolate);
auto Context = v8::Local<v8::Context>::New(Isolate, DefaultContext);
v8::Context::Scope ContextScope(Context);
// TODO: catch uv_run可以让脚本错误不至于进程退出，但这不知道会不会对node有什么副作用
v8::TryCatch TryCatch(Isolate);
uv_run(&NodeUVLoop, UV_RUN_NOWAIT);
if (TryCatch.HasCaught())
{
Logger->Error(FString::Printf(TEXT("uv_run throw: %s"), *FV8Utils::TryCatchToString(Isolate, &TryCatch)));
}
else
{
static_cast<node::MultiIsolatePlatform*>(IJsEnvModule::Get().GetV8Platform())->DrainTasks(Isolate);
}
LastJob = nullptr;
// Tell the Polling thread to continue.
uv_sem_post(&PollingSem);
}
void FJsEnvImpl::PollEvents()
{
#if PLATFORM_WINDOWS
DWORD bytes;
DWORD timeout = uv_backend_timeout(&NodeUVLoop);
ULONG_PTR key;
OVERLAPPED* overlapped;
timeout = timeout > 100 ? 100 : timeout;
GetQueuedCompletionStatus(NodeUVLoop.iocp, &bytes, &key, &overlapped, timeout);
// Give the event back so libuv can deal with it.
if (overlapped != NULL)
PostQueuedCompletionStatus(NodeUVLoop.iocp, bytes, key, overlapped);
#elif PLATFORM_LINUX
int timeout = uv_backend_timeout(&NodeUVLoop);
timeout = (timeout > 100 || timeout < 0) ? 100 : timeout;
// Wait for new libuv events.
int r;
do
{
struct epoll_event ev;
r = epoll_wait(Epoll, &ev, 1, timeout);
} while (r == -1 && errno == EINTR);
#elif PLATFORM_MAC
struct timeval tv;
int timeout = uv_backend_timeout(&NodeUVLoop);
timeout = (timeout > 100 || timeout < 0) ? 100 : timeout;
if (timeout != -1)
{
tv.tv_sec = timeout / 1000;
tv.tv_usec = (timeout % 1000) * 1000;
}
fd_set readset;
int fd = uv_backend_fd(&NodeUVLoop);
FD_ZERO(&readset);
FD_SET(fd, &readset);
// Wait for new libuv events.
int r;
do
{
r = select(fd + 1, &readset, nullptr, nullptr, timeout == -1 ? nullptr : &tv);
} while (r == -1 && errno == EINTR);
#endif
}
void FJsEnvImpl::OnWatcherQueueChanged(uv_loop_t* loop)
{
#if !PLATFORM_WINDOWS
FJsEnvImpl* self = static_cast<FJsEnvImpl*>(loop->data);
self->WakeupPollingThread();
#endif
}
void FJsEnvImpl::WakeupPollingThread()
{
uv_async_send(&DummyUVHandle);
}
void FJsEnvImpl::StopPolling()
{
PollingClosed = true;
uv_sem_post(&PollingSem);
WakeupPollingThread();
uv_thread_join(&PollingThread);
if (LastJob)
{
LastJob->Wait();
}
uv_sem_destroy(&PollingSem);
}
#endif
#if defined(WITH_V8_BYTECODE)
struct FCodeCacheHeader
{
uint32_t MagicNumber;
uint32_t VersionHash;
uint32_t SourceHash;
uint32_t FlagHash;
#if V8_MAJOR_VERSION >= 11
uint32_t ReadOnlySnapshotChecksum;
#endif
uint32_t PayloadLength;
uint32_t Checksum;
};
#endif
FJsEnvImpl::FJsEnvImpl(std::shared_ptr<IJSModuleLoader> InModuleLoader, std::shared_ptr<ILogger> InLogger, int InDebugPort,
std::function<void(const FString&)> InOnSourceLoadedCallback, const FString InFlags, void* InExternalRuntime,
void* InExternalContext)
{
GUObjectArray.AddUObjectDeleteListener(static_cast<FUObjectArray::FUObjectDeleteListener*>(this));
if (!InFlags.IsEmpty())
{
#if !defined(WITH_NODEJS) && !defined(WITH_QUICKJS)
TArray<FString> FlagArray;
InFlags.ParseIntoArray(FlagArray, TEXT(" "));
for (auto& Flag : FlagArray)
{
static FString Max_Old_Space_Size_Name(TEXT("--max-old-space-size="));
if (Flag.StartsWith(Max_Old_Space_Size_Name))
{
size_t Val = FCString::Atoi(*Flag.Mid(Max_Old_Space_Size_Name.Len()));
CreateParams.constraints.set_max_old_generation_size_in_bytes(Val * 1024 * 1024);
}
}
#endif
}
Started = false;
Inspector = nullptr;
InspectorChannel = nullptr;
ModuleLoader = std::move(InModuleLoader);
Logger = InLogger;
OnSourceLoadedCallback = InOnSourceLoadedCallback;
#if !defined(WITH_NODEJS)
#if V8_MAJOR_VERSION < 8 && !defined(WITH_QUICKJS)
std::unique_ptr<v8::StartupData> NativesBlob;
if (!NativesBlob)
{
NativesBlob = std::make_unique<v8::StartupData>();
NativesBlob->data = (const char*) NativesBlobCode;
NativesBlob->raw_size = sizeof(NativesBlobCode);
}
v8::V8::SetNativesDataBlob(NativesBlob.get());
#endif
CreateParams.array_buffer_allocator = v8::ArrayBuffer::Allocator::NewDefaultAllocator();
#ifdef WITH_QUICKJS
MainIsolate = InExternalRuntime ? v8::Isolate::New(InExternalRuntime) : v8::Isolate::New(CreateParams);
#else
check(!InExternalRuntime && !InExternalContext);
MainIsolate = v8::Isolate::New(CreateParams);
#endif
auto Isolate = MainIsolate;
#ifdef THREAD_SAFE
v8::Locker Locker(Isolate);
#endif
Isolate->SetData(0, static_cast<IObjectMapper*>(this)); //直接传this会有问题，强转后地址会变
v8::Isolate::Scope Isolatescope(Isolate);
v8::HandleScope HandleScope(Isolate);
#ifdef WITH_QUICKJS
v8::Local<v8::Context> Context =
(InExternalRuntime && InExternalContext) ? v8::Context::New(Isolate, InExternalContext) : v8::Context::New(Isolate);
#else
v8::Local<v8::Context> Context = v8::Context::New(Isolate);
#endif
#else
int Argc = 1;
const char* Argv[] = {"puerts"};
std::vector<std::string> Args(Argv, Argv + Argc);
std::vector<std::string> ExecArgs;
std::vector<std::string> Errors;
const int Ret = uv_loop_init(&NodeUVLoop);
if (Ret != 0)
{
Logger->Error(FString::Printf(TEXT("Failed to initialize loop: %s\n"), UTF8_TO_TCHAR(uv_err_name(Ret))));
return;
}
CreateParams.array_buffer_allocator = nullptr;
NodeArrayBufferAllocator = node::ArrayBufferAllocator::Create();
auto Platform = static_cast<node::MultiIsolatePlatform*>(IJsEnvModule::Get().GetV8Platform());
MainIsolate = node::NewIsolate(NodeArrayBufferAllocator.get(), &NodeUVLoop, Platform);
auto Isolate = MainIsolate;
#ifdef THREAD_SAFE
v8::Locker Locker(Isolate);
#endif
Isolate->SetData(0, static_cast<IObjectMapper*>(this)); //直接传this会有问题，强转后地址会变
// v8::Locker locker(Isolate);
// difference from embedding example, if lock, blow check fail:
// Utils::ApiCheck(
//! v8::Locker::IsActive() ||
// internal_isolate->thread_manager()->IsLockedByCurrentThread() ||
// internal_isolate->serializer_enabled(),
//"HandleScope::HandleScope",
//"Entering the V8 API without proper locking in place");
v8::Isolate::Scope Isolatescope(Isolate);
NodeIsolateData =
node::CreateIsolateData(Isolate, &NodeUVLoop, Platform, NodeArrayBufferAllocator.get()); // node::FreeIsolateData
v8::HandleScope HandleScope(Isolate);
v8::Local<v8::Context> Context = node::NewContext(Isolate);
#endif
DefaultContext.Reset(Isolate, Context);
v8::Context::Scope ContextScope(Context);
#if defined(WITH_NODEJS)
// kDefaultFlags = kOwnsProcessState | kOwnsInspector, if kOwnsInspector set, inspector_agent.cc:681
// CHECK_EQ(start_io_thread_async_initialized.exchange(true), false) fail!
NodeEnv = CreateEnvironment(NodeIsolateData, Context, Args, ExecArgs, node::EnvironmentFlags::kOwnsProcessState);
v8::MaybeLocal<v8::Value> LoadenvRet = node::LoadEnvironment(NodeEnv,
"const publicRequire ="
" require('module').createRequire(process.cwd() + '/');"
"globalThis.require = publicRequire;");
if (LoadenvRet.IsEmpty()) // There has been a JS exception.
{
return;
}
// the same as raw v8
Isolate->SetMicrotasksPolicy(v8::MicrotasksPolicy::kAuto);
StartPolling();
#endif
v8::Local<v8::Object> Global = Context->Global();
v8::Local<v8::Object> PuertsObj = v8::Object::New(Isolate);
Global->Set(Context, FV8Utils::InternalString(Isolate, "puerts"), PuertsObj).Check();
auto This = v8::External::New(Isolate, this);
MethodBindingHelper<&FJsEnvImpl::EvalScript>::Bind(Isolate, Context, Global, "__tgjsEvalScript", This);
MethodBindingHelper<&FJsEnvImpl::Log>::Bind(Isolate, Context, Global, "__tgjsLog", This);
MethodBindingHelper<&FJsEnvImpl::SearchModule>::Bind(Isolate, Context, Global, "__tgjsSearchModule", This);
MethodBindingHelper<&FJsEnvImpl::LoadModule>::Bind(Isolate, Context, Global, "__tgjsLoadModule", This);
MethodBindingHelper<&FJsEnvImpl::LoadUEType>::Bind(Isolate, Context, PuertsObj, "loadUEType", This);
MethodBindingHelper<&FJsEnvImpl::LoadCppType>::Bind(Isolate, Context, PuertsObj, "loadCPPType", This);
MethodBindingHelper<&FJsEnvImpl::UEClassToJSClass>::Bind(Isolate, Context, Global, "__tgjsUEClassToJSClass", This);
MethodBindingHelper<&FJsEnvImpl::NewContainer>::Bind(Isolate, Context, Global, "__tgjsNewContainer", This);
MethodBindingHelper<&FJsEnvImpl::MergeObject>::Bind(Isolate, Context, Global, "__tgjsMergeObject", This);
MethodBindingHelper<&FJsEnvImpl::NewObjectByClass>::Bind(Isolate, Context, Global, "__tgjsNewObject", This);
MethodBindingHelper<&FJsEnvImpl::SetJsTakeRefInTs>::Bind(Isolate, Context, Global, "__tgjsSetJsTakeRef", This);
MethodBindingHelper<&FJsEnvImpl::NewStructByScriptStruct>::Bind(Isolate, Context, Global, "__tgjsNewStruct", This);
#if !defined(ENGINE_INDEPENDENT_JSENV)
MethodBindingHelper<&FJsEnvImpl::MakeUClass>::Bind(Isolate, Context, Global, "__tgjsMakeUClass", This);
MethodBindingHelper<&FJsEnvImpl::Mixin>::Bind(Isolate, Context, Global, "__tgjsMixin", This);
#endif
MethodBindingHelper<&FJsEnvImpl::FindModule>::Bind(Isolate, Context, Global, "__tgjsFindModule", This);
MethodBindingHelper<&FJsEnvImpl::SetInspectorCallback>::Bind(Isolate, Context, Global, "__tgjsSetInspectorCallback", This);
MethodBindingHelper<&FJsEnvImpl::DispatchProtocolMessage>::Bind(
Isolate, Context, Global, "__tgjsDispatchProtocolMessage", This);
Isolate->SetPromiseRejectCallback(&PromiseRejectCallback<FJsEnvImpl>);
Global
->Set(Context, FV8Utils::ToV8String(Isolate, "__tgjsSetPromiseRejectCallback"),
v8::FunctionTemplate::New(Isolate, &SetPromiseRejectCallback<FJsEnvImpl>)->GetFunction(Context).ToLocalChecked())
.Check();
//#if !defined(WITH_NODEJS)
MethodBindingHelper<&FJsEnvImpl::SetTimeout>::Bind(Isolate, Context, Global, "setTimeout", This);
MethodBindingHelper<&FJsEnvImpl::ClearInterval>::Bind(Isolate, Context, Global, "clearTimeout", This);
MethodBindingHelper<&FJsEnvImpl::SetInterval>::Bind(Isolate, Context, Global, "setInterval", This);
MethodBindingHelper<&FJsEnvImpl::ClearInterval>::Bind(Isolate, Context, Global, "clearInterval", This);
//#endif
#if USE_WASM3
MethodBindingHelper<&FJsEnvImpl::Wasm_NewMemory>::Bind(Isolate, Context, Global, "__tgjsWasm_NewMemory", This);
MethodBindingHelper<&FJsEnvImpl::Wasm_MemoryGrowth>::Bind(Isolate, Context, Global, "__tgjsWasm_MemoryGrowth", This);
MethodBindingHelper<&FJsEnvImpl::Wasm_MemoryBuffer>::Bind(Isolate, Context, Global, "__tgjsWasm_MemoryBuffer", This);
MethodBindingHelper<&FJsEnvImpl::Wasm_TableGrowth>::Bind(Isolate, Context, Global, "__tgjsWasm_TableGrow", This);
MethodBindingHelper<&FJsEnvImpl::Wasm_TableSet>::Bind(Isolate, Context, Global, "__tgjsWasm_TableSet", This);
MethodBindingHelper<&FJsEnvImpl::Wasm_TableLen>::Bind(Isolate, Context, Global, "__tgjsWasm_TableLen", This);
MethodBindingHelper<&FJsEnvImpl::Wasm_Instance>::Bind(Isolate, Context, Global, "__tgjsWasm_Instance", This);
MethodBindingHelper<&FJsEnvImpl::Wasm_OverrideWebAssembly>::Bind(
Isolate, Context, Global, "__tgjsWasm_OverrideWebAssembly", This);
#endif
MethodBindingHelper<&FJsEnvImpl::DumpStatisticsLog>::Bind(Isolate, Context, Global, "dumpStatisticsLog", This);
Global
->Set(Context, FV8Utils::ToV8String(Isolate, "__tgjsFNameToArrayBuffer"),
v8::FunctionTemplate::New(Isolate, FNameToArrayBuffer)->GetFunction(Context).ToLocalChecked())
.Check();
PuertsObj
->Set(Context, FV8Utils::ToV8String(Isolate, "toCString"),
v8::FunctionTemplate::New(Isolate, ToCString)->GetFunction(Context).ToLocalChecked())
.Check();
PuertsObj
->Set(Context, FV8Utils::ToV8String(Isolate, "toCPtrArray"),
v8::FunctionTemplate::New(Isolate, ToCPtrArray)->GetFunction(Context).ToLocalChecked())
.Check();
#if !defined(WITH_QUICKJS)
PuertsObj
->Set(Context, FV8Utils::ToV8String(Isolate, "load"),
v8::FunctionTemplate::New(Isolate, LoadPesapiDll)->GetFunction(Context).ToLocalChecked())
.Check();
#endif
FString DllExt =
#if PLATFORM_WINDOWS
TEXT(".dll");
#elif PLATFORM_MAC || PLATFORM_IOS
TEXT(".dylib");
#else
TEXT(".so");
#endif
PuertsObj->Set(Context, FV8Utils::ToV8String(Isolate, "dll_ext"), FV8Utils::ToV8String(Isolate, DllExt)).Check();
MethodBindingHelper<&FJsEnvImpl::ReleaseManualReleaseDelegate>::Bind(
Isolate, Context, PuertsObj, "releaseManualReleaseDelegate", This);
ArrayTemplate = v8::UniquePersistent<v8::FunctionTemplate>(Isolate, FScriptArrayWrapper::ToFunctionTemplate(Isolate));
SetTemplate = v8::UniquePersistent<v8::FunctionTemplate>(Isolate, FScriptSetWrapper::ToFunctionTemplate(Isolate));
MapTemplate = v8::UniquePersistent<v8::FunctionTemplate>(Isolate, FScriptMapWrapper::ToFunctionTemplate(Isolate));
FixSizeArrayTemplate = v8::UniquePersistent<v8::FunctionTemplate>(Isolate, FFixSizeArrayWrapper::ToFunctionTemplate(Isolate));
CppObjectMapper.Initialize(Isolate, Context);
DelegateTemplate = v8::UniquePersistent<v8::FunctionTemplate>(Isolate, FDelegateWrapper::ToFunctionTemplate(Isolate));
MulticastDelegateTemplate =
v8::UniquePersistent<v8::FunctionTemplate>(Isolate, FMulticastDelegateWrapper::ToFunctionTemplate(Isolate));
SoftObjectPtrTemplate = v8::UniquePersistent<v8::FunctionTemplate>(Isolate, FSoftObjectWrapper::ToFunctionTemplate(Isolate));
DynamicInvoker = MakeShared<DynamicInvokerImpl, ESPMode::ThreadSafe>(this);
MixinInvoker = DynamicInvoker;
#if !defined(ENGINE_INDEPENDENT_JSENV)
TsDynamicInvoker = MakeShared<TsDynamicInvokerImpl, ESPMode::ThreadSafe>(this);
#endif
Inspector = CreateV8Inspector(InDebugPort, &Context);
ExecuteModule("puerts/first_run.js");
#if !defined(WITH_NODEJS)
ExecuteModule("puerts/polyfill.js");
#endif
ExecuteModule("puerts/log.js");
ExecuteModule("puerts/modular.js");
ExecuteModule("puerts/uelazyload.js");
ExecuteModule("puerts/events.js");
ExecuteModule("puerts/promises.js");
ExecuteModule("puerts/argv.js");
ExecuteModule("puerts/jit_stub.js");
ExecuteModule("puerts/hot_reload.js");
ExecuteModule("puerts/pesaddon.js");
Require.Reset(Isolate, PuertsObj->Get(Context, FV8Utils::ToV8String(Isolate, "__require")).ToLocalChecked().As<v8::Function>());
GetESMMain.Reset(
Isolate, PuertsObj->Get(Context, FV8Utils::ToV8String(Isolate, "getESMMain")).ToLocalChecked().As<v8::Function>());
ReloadJs.Reset(Isolate, PuertsObj->Get(Context, FV8Utils::ToV8String(Isolate, "__reload")).ToLocalChecked().As<v8::Function>());
#if !PUERTS_FORCE_CPP_UFUNCTION
MergePrototype.Reset(
Isolate, PuertsObj->Get(Context, FV8Utils::ToV8String(Isolate, "__mergePrototype")).ToLocalChecked().As<v8::Function>());
#endif
RemoveListItem.Reset(
Isolate, PuertsObj->Get(Context, FV8Utils::ToV8String(Isolate, "__removeListItem")).ToLocalChecked().As<v8::Function>());
GenListApply.Reset(
Isolate, PuertsObj->Get(Context, FV8Utils::ToV8String(Isolate, "__genListApply")).ToLocalChecked().As<v8::Function>());
#if defined(WITH_V8_BYTECODE)
GenEmptyCode.Reset(
Isolate, PuertsObj->Get(Context, FV8Utils::ToV8String(Isolate, "generateEmptyCode")).ToLocalChecked().As<v8::Function>());
#endif
DelegateProxiesCheckerHandler =
FUETicker::GetCoreTicker().AddTicker(FTickerDelegate::CreateRaw(this, &FJsEnvImpl::CheckDelegateProxies), 1);
ManualReleaseCallbackMap.Reset(Isolate, v8::Map::New(Isolate));
UserObjectRetainer.SetName(TEXT("Puerts_UserObjectRetainer"));
SysObjectRetainer.SetName(TEXT("Puerts_SysObjectRetainer"));
#ifdef SINGLE_THREAD_VERIFY
BoundThreadId = FPlatformTLS::GetCurrentThreadId();
#endif
#if USE_WASM3
PuertsWasmEnv = std::make_shared<WasmEnv>();
//创建默认的runtime
PuertsWasmRuntimeList.Add(std::make_shared<WasmRuntime>(PuertsWasmEnv.get()));
ExecuteModule("puerts/wasm3_helper.js");
#endif
#if defined(WITH_V8_BYTECODE)
auto Script = v8::Script::Compile(Context, FV8Utils::ToV8String(Isolate, "")).ToLocalChecked();
auto CachedCode = v8::ScriptCompiler::CreateCodeCache(Script->GetUnboundScript());
const FCodeCacheHeader* CodeCacheHeader = (const FCodeCacheHeader*) CachedCode->data;
Expect_FlagHash = CodeCacheHeader->FlagHash; // get FlagHash
#if V8_MAJOR_VERSION >= 11
Expect_ReadOnlySnapshotChecksum = CodeCacheHeader->ReadOnlySnapshotChecksum;
#endif
#if !WITH_EDITOR
delete CachedCode; //编辑器下是v8.dll分配的，ue里的delete被重载了，这delete会有问题
#endif
#endif
#if defined(WITH_WEBSOCKET)
InitWebsocketPPWrap(Context);
ExecuteModule("puerts/websocketpp.js");
#endif
}
// #lizard forgives
FJsEnvImpl::~FJsEnvImpl()
{
#if USE_WASM3
PuertsWasmRuntimeList.Empty();
PuertsWasmEnv.reset();
for (auto Item : PuertsWasmCachedLinkFunctionList)
{
Item->CachedFunction.Reset();
delete Item;
}
PuertsWasmCachedLinkFunctionList.Empty();
#endif
#ifdef SINGLE_THREAD_VERIFY
ensureMsgf(BoundThreadId == FPlatformTLS::GetCurrentThreadId(), TEXT("Access by illegal thread!"));
#endif
#if defined(WITH_NODEJS)
StopPolling();
#endif
#ifndef WITH_QUICKJS
for (auto& KV : HashToModuleInfo)
{
delete KV.second;
}
HashToModuleInfo.clear();
PathToModule.Empty();
#endif
for (int i = 0; i < ManualReleaseCallbackList.size(); i++)
{
if (ManualReleaseCallbackList[i].IsValid(true))
{
ManualReleaseCallbackList[i].Get()->JsFunction.Reset();
}
}
ManualReleaseCallbackMap.Reset();
InspectorMessageHandler.Reset();
Require.Reset();
GetESMMain.Reset();
ReloadJs.Reset();
JsPromiseRejectCallback.Reset();
FUETicker::GetCoreTicker().RemoveTicker(DelegateProxiesCheckerHandler);
{
auto Isolate = MainIsolate;
#ifdef THREAD_SAFE
v8::Locker Locker(Isolate);
#endif
v8::Isolate::Scope IsolateScope(Isolate);
v8::HandleScope HandleScope(Isolate);
TypeToTemplateInfoMap.Empty();
CppObjectMapper.UnInitialize(Isolate);
ObjectMap.Empty();
for (auto& KV : StructCache)
{
FObjectCacheNode* PNode = &KV.Value;
while (PNode)
{
PNode->Value.Reset();
PNode = PNode->Next;
}
}
for (auto& KV : ContainerCache)
{
if (KV.Value.NeedRelease)
{
switch (KV.Value.Type)
{
case EArray:
delete static_cast<FScriptArrayEx*>(KV.Key);
break;
case EMap:
delete static_cast<FScriptMapEx*>(KV.Key);
break;
case ESet:
delete static_cast<FScriptSetEx*>(KV.Key);
break;
}
}
}
ContainerCache.Empty();
for (auto Iter = DelegateMap.begin(); Iter != DelegateMap.end(); Iter++)
{
Iter->second.JSObject.Reset();
if (Iter->second.Proxy.IsValid(true))
{
Iter->second.Proxy->JsFunction.Reset();
}
if (!Iter->second.PassByPointer)
{
delete ((FScriptDelegate*) Iter->first);
}
Iter->second.JsCallbacks.Reset();
}
for (auto& KV : AutoReleaseCallbacksMap)
{
for (auto& Callback : KV.Value)
{
if (Callback.IsValid(true))
{
Callback->JsFunction.Reset();
}
}
}
TsFunctionMap.Empty();
MixinFunctionMap.Empty();
#if !defined(ENGINE_INDEPENDENT_JSENV)
TsDynamicInvoker.Reset();
BindInfoMap.Empty();
#endif
for (auto Iter = TimerInfos.CreateIterator(); Iter; ++Iter)
{
Iter->Value.Callback.Reset();
FUETicker::GetCoreTicker().RemoveTicker(Iter->Value.TickerHandle);
}
TimerInfos.Empty();
#if !defined(ENGINE_INDEPENDENT_JSENV)
for (auto& GeneratedClass : GeneratedClasses)
{
if (auto JSGeneratedClass = Cast<UJSGeneratedClass>(GeneratedClass))
{
if (JSGeneratedClass->IsValidLowLevelFast() && !UEObjectIsPendingKill(JSGeneratedClass))
{
JSGeneratedClass->Release();
}
}
else if (auto JSWidgetGeneratedClass = Cast<UJSWidgetGeneratedClass>(GeneratedClass))
{
if (JSWidgetGeneratedClass->IsValidLowLevelFast() && !UEObjectIsPendingKill(JSWidgetGeneratedClass))
{
JSWidgetGeneratedClass->Release();
}
}
else if (auto JSAnimGeneratedClass = Cast<UJSAnimGeneratedClass>(GeneratedClass))
{
if (JSWidgetGeneratedClass->IsValidLowLevelFast() && !UEObjectIsPendingKill(JSWidgetGeneratedClass))
{
JSAnimGeneratedClass->Release();
}
}
}
#endif
#if defined(WITH_NODEJS)
node::EmitExit(NodeEnv);
node::Stop(NodeEnv);
node::FreeEnvironment(NodeEnv);
node::FreeIsolateData(NodeIsolateData);
auto Platform = static_cast<node::MultiIsolatePlatform*>(IJsEnvModule::Get().GetV8Platform());
Platform->UnregisterIsolate(Isolate);
#endif
if (InspectorChannel)
{
delete InspectorChannel;
InspectorChannel = nullptr;
}
if (Inspector)
{
delete Inspector;
Inspector = nullptr;
}
DynamicInvoker.Reset();
MixinInvoker.Reset();
SoftObjectPtrTemplate.Reset();
MulticastDelegateTemplate.Reset();
DelegateTemplate.Reset();
FixSizeArrayTemplate.Reset();
MapTemplate.Reset();
SetTemplate.Reset();
ArrayTemplate.Reset();
#if !PUERTS_FORCE_CPP_UFUNCTION
MergePrototype.Reset();
#endif
RemoveListItem.Reset();
GenListApply.Reset();
#if defined(WITH_V8_BYTECODE)
GenEmptyCode.Reset();
#endif
}
#if !defined(ENGINE_INDEPENDENT_JSENV)
for (size_t i = 0; i < MixinClasses.Num(); i++)
{
if (MixinClasses[i].IsValid())
{
UJSGeneratedClass::Restore(MixinClasses[i].Get());
}
}
#endif
#if PUERTS_REUSE_STRUCTWRAPPER_FUNCTIONTEMPLATE
for (auto Iter = TypeReflectionMap.CreateIterator(); Iter; ++Iter)
{
Iter->Value->CachedFunctionTemplate.Reset();
}
#endif
DefaultContext.Reset();
MainIsolate->Dispose();
MainIsolate = nullptr;
delete CreateParams.array_buffer_allocator;
GUObjectArray.RemoveUObjectDeleteListener(static_cast<FUObjectArray::FUObjectDeleteListener*>(this));
// quickjs will call UnBind in vm dispose, so cleanup move to here
for (auto& KV : StructCache)
{
FObjectCacheNode* PNode = &KV.Value;
while (PNode)
{
if (PNode->UserData)
{
FScriptStructWrapper* ScriptStructWrapper = (FScriptStructWrapper*) (PNode->UserData);
ScriptStructWrapper->Free(KV.Key);
}
PNode = PNode->Next;
}
}
StructCache.Empty();
}
void FJsEnvImpl::InitExtensionMethodsMap()
{
#ifdef SINGLE_THREAD_VERIFY
ensureMsgf(BoundThreadId == FPlatformTLS::GetCurrentThreadId(), TEXT("Access by illegal thread!"));
#endif
#ifdef THREAD_SAFE
v8::Locker Locker(MainIsolate);
#endif
#if !defined(ENGINE_INDEPENDENT_JSENV)
for (TObjectIterator<UClass> It; It; ++It)
{
UClass* Class = *It;
if (Class->IsChildOf<UExtensionMethods>() && Class->IsNative())
{
for (TFieldIterator<UFunction> FuncIt(Class, EFieldIteratorFlags::ExcludeSuper); FuncIt; ++FuncIt)
{
UFunction* Function = *FuncIt;
if (Function->HasAnyFunctionFlags(FUNC_Static))
{
TFieldIterator<PropertyMacro> ParamIt(Function);
if (ParamIt &&
((ParamIt->PropertyFlags & (CPF_Parm | CPF_ReturnParm)) == CPF_Parm)) // has at least one param
{
UStruct* Struct = nullptr;
if (auto ObjectPropertyBase = CastFieldMacro<ObjectPropertyBaseMacro>(*ParamIt))
{
Struct = ObjectPropertyBase->PropertyClass;
}
else if (auto StructProperty = CastFieldMacro<StructPropertyMacro>(*ParamIt))
{
Struct = StructProperty->Struct;
}
if (Struct)
{
if (ExtensionMethodsMap.find(Struct) == ExtensionMethodsMap.end())
{
ExtensionMethodsMap[Struct] = std::vector<UFunction*>();
}
auto Iter = ExtensionMethodsMap.find(Struct);
if (std::find(Iter->second.begin(), Iter->second.end(), Function) == Iter->second.end())
{
Iter->second.push_back(Function);
}
}
}
}
}
}
}
#endif
ExtensionMethodsMapInited = true;
}
std::unique_ptr<FJsEnvImpl::ObjectMerger>& FJsEnvImpl::GetObjectMerger(UStruct* Struct)
{
if (ObjectMergers.find(Struct) == ObjectMergers.end())
{
ObjectMergers[Struct] = std::make_unique<ObjectMerger>(this, Struct);
}
return ObjectMergers[Struct];
}
void FJsEnvImpl::Merge(v8::Isolate* Isolate, v8::Local<v8::Context> Context, v8::Local<v8::Object> Src, UStruct* DesType, void* Des)
{
GetObjectMerger(DesType)->Merge(Isolate, Context, Src, Des);
}
void FJsEnvImpl::MergeObject(const v8::FunctionCallbackInfo<v8::Value>& Info)
{
v8::Isolate* Isolate = Info.GetIsolate();
v8::Isolate::Scope Isolatescope(Isolate);
v8::HandleScope HandleScope(Isolate);
v8::Local<v8::Context> Context = Isolate->GetCurrentContext();
v8::Context::Scope ContextScope(Context);
CHECK_V8_ARGS(EArgObject, EArgObject);
auto Des = Info[0]->ToObject(Context).ToLocalChecked();
auto Src = Info[1]->ToObject(Context).ToLocalChecked();
if (FV8Utils::GetPointerFast<void>(Des, 1)) // struct
{
if (auto Object = FV8Utils::GetUObject(Des, 1))
{
if (FV8Utils::IsReleasedPtr(Object))
{
FV8Utils::ThrowException(Isolate, "passing a invalid object");
return;
}
auto Struct = Cast<UScriptStruct>(Object);
if (Struct)
{
Merge(Isolate, Context, Src, Struct, FV8Utils::GetPointer(Des));
return;
}
}
}
else // class
{
auto Object = FV8Utils::GetUObject(Des);
if (Object)
{
if (FV8Utils::IsReleasedPtr(Object))
{
FV8Utils::ThrowException(Isolate, "passing a invalid object");
return;
}
Merge(Isolate, Context, Src, Object->GetClass(), Object);
return;
}
}
FV8Utils::ThrowException(Isolate, "Bad parameters #1, expect a native object.");
}
void FJsEnvImpl::NewObjectByClass(const v8::FunctionCallbackInfo<v8::Value>& Info)
{
v8::Isolate* Isolate = Info.GetIsolate();
v8::Isolate::Scope IsolateScope(Isolate);
v8::HandleScope HandleScope(Isolate);
v8::Local<v8::Context> Context = Isolate->GetCurrentContext();
v8::Context::Scope ContextScope(Context);
UObject* Outer = GetTransientPackage();
FName Name = NAME_None;
EObjectFlags ObjectFlags = RF_NoFlags;
UClass* Class = nullptr;
if (UObject* Object = FV8Utils::GetUObject(Context, Info[0]))
{
if (FV8Utils::IsReleasedPtr(Object))
{
FV8Utils::ThrowException(Isolate, "passing a invalid object");
return;
}
Class = Cast<UClass>(Object);
}
if (Class)
{
if (Info.Length() > 1 && !Info[1]->IsNullOrUndefined())
{
Outer = FV8Utils::GetUObject(Context, Info[1]);
if (FV8Utils::IsReleasedPtr(Outer))
{
FV8Utils::ThrowException(Isolate, "passing a invalid object");
return;
}
}
if (Info.Length() > 2 && !Info[2]->IsNullOrUndefined())
{
Name = FName(*FV8Utils::ToFString(Isolate, Info[2]));
}
if (Info.Length() > 3 && !Info[3]->IsNullOrUndefined())
{
ObjectFlags = (EObjectFlags) (Info[3]->Int32Value(Context).ToChecked());
}
UObject* Object = NewObject<UObject>(Outer, Class, Name, ObjectFlags);
auto Result = FV8Utils::IsolateData<IObjectMapper>(Isolate)->FindOrAdd(Isolate, Context, Object->GetClass(), Object);
#if !PUERTS_KEEP_UOBJECT_REFERENCE
bool NeedJsTakeRef = true;
if (Info.Length() > 4 && !Info[4]->IsNullOrUndefined())
{
if (!Info[4]->BooleanValue(Isolate))
{
NeedJsTakeRef = false;
}
}
if (NeedJsTakeRef)
{
bool Existed;
auto TemplateInfoPtr = GetTemplateInfoOfType(Class, Existed);
SetJsTakeRef(Object, static_cast<FClassWrapper*>(TemplateInfoPtr->StructWrapper.get()));
}
#endif
Info.GetReturnValue().Set(Result);
}
else
{
FV8Utils::ThrowException(Isolate, "invalid argument");
}
}
void FJsEnvImpl::NewStructByScriptStruct(const v8::FunctionCallbackInfo<v8::Value>& Info)
{
v8::Isolate* Isolate = Info.GetIsolate();
v8::Isolate::Scope IsolateScope(Isolate);
v8::HandleScope HandleScope(Isolate);
v8::Local<v8::Context> Context = Isolate->GetCurrentContext();
v8::Context::Scope ContextScope(Context);
UScriptStruct* ScriptStruct = nullptr;
if (UObject* Object = FV8Utils::GetUObject(Context, Info[0]))
{
if (FV8Utils::IsReleasedPtr(Object))
{
FV8Utils::ThrowException(Isolate, "passing a invalid object");
return;
}
ScriptStruct = Cast<UScriptStruct>(Object);
}
if (ScriptStruct)
{
void* Ptr = FScriptStructWrapper::Alloc(ScriptStruct);
Info.GetReturnValue().Set(
FV8Utils::IsolateData<IObjectMapper>(Isolate)->FindOrAddStruct(Isolate, Context, ScriptStruct, Ptr, false));
}
else
{
FV8Utils::ThrowException(Isolate, "invalid argument");
}
}
bool FJsEnvImpl::IdleNotificationDeadline(double DeadlineInSeconds)
{
#ifdef THREAD_SAFE
v8::Locker Locker(MainIsolate);
#endif
#ifndef WITH_QUICKJS
return MainIsolate->IdleNotificationDeadline(DeadlineInSeconds);
#else
return true;
#endif
}
void FJsEnvImpl::LowMemoryNotification()
{
#ifdef SINGLE_THREAD_VERIFY
ensureMsgf(BoundThreadId == FPlatformTLS::GetCurrentThreadId(), TEXT("Access by illegal thread!"));
#endif
#ifdef THREAD_SAFE
v8::Locker Locker(MainIsolate);
#endif
MainIsolate->LowMemoryNotification();
}
void FJsEnvImpl::RequestMinorGarbageCollectionForTesting()
{
#ifdef THREAD_SAFE
v8::Locker Locker(MainIsolate);
#endif
#ifndef WITH_QUICKJS
MainIsolate->RequestGarbageCollectionForTesting(v8::Isolate::kMinorGarbageCollection);
#endif
}
void FJsEnvImpl::RequestFullGarbageCollectionForTesting()
{
#ifdef THREAD_SAFE
v8::Locker Locker(MainIsolate);
#endif
#ifndef WITH_QUICKJS
MainIsolate->RequestGarbageCollectionForTesting(v8::Isolate::kFullGarbageCollection);
#endif
}
#if !defined(ENGINE_INDEPENDENT_JSENV)
void FJsEnvImpl::FinishInjection(UClass* InClass)
{
while (InClass && !InClass->IsNative())
{
auto TempTypeScriptGeneratedClass = Cast<UTypeScriptGeneratedClass>(InClass);
if (TempTypeScriptGeneratedClass) // InjectNotFinished状态下，其子类的CDO对象构建，把UFunction设置为Native
{
auto BindInfoPtr = BindInfoMap.Find(TempTypeScriptGeneratedClass);
if (BindInfoPtr && BindInfoPtr->InjectNotFinished)
{
TempTypeScriptGeneratedClass->RedirectToTypeScriptFinish();
BindInfoPtr->InjectNotFinished = false;
}
}
InClass = InClass->GetSuperClass();
}
}
void FJsEnvImpl::MakeSureInject(UTypeScriptGeneratedClass* TypeScriptGeneratedClass, bool ForceReinject, bool RebindObject)
{
#ifdef SINGLE_THREAD_VERIFY
ensureMsgf(BoundThreadId == FPlatformTLS::GetCurrentThreadId(), TEXT("Access by illegal thread!"));
#endif
#if WITH_EDITOR
if (TypeScriptGeneratedClass->NeedReBind)
{
UTypeScriptGeneratedClass::NotifyRebind(TypeScriptGeneratedClass);
}
#endif
auto BindInfoPtr = BindInfoMap.Find(TypeScriptGeneratedClass);
if (!BindInfoPtr || ForceReinject) // create and link
{
auto Package = Cast<UPackage>(TypeScriptGeneratedClass->GetOuter());
if (!Package || TypeScriptGeneratedClass->NotSupportInject())
{
return;
}
auto PackageName = Package->GetName();
static FString PackageNamePrefix(TEXT(TS_BLUEPRINT_PATH));
auto PrefixPos = PackageName.Find(PackageNamePrefix);
if (PrefixPos != INDEX_NONE)
{
auto SuperClass = Cast<UTypeScriptGeneratedClass>(TypeScriptGeneratedClass->GetSuperClass());
if (SuperClass && SuperClass->GetName().StartsWith(TEXT("REINST_")))
{
//中间状态，父类修改，子类可能有个中间状态，其父类可能被修改为一个REINST_前缀的临时类
return;
}
if (SuperClass)
{
MakeSureInject(SuperClass, false, RebindObject);
}
FString ModuleName = PackageName.Mid(PrefixPos + PackageNamePrefix.Len());
Logger->Info(FString::Printf(TEXT("Bind module [%s] "), *ModuleName));
auto Isolate = MainIsolate;
v8::Isolate::Scope IsolateScope(Isolate);
v8::HandleScope HandleScope(Isolate);
auto Context = DefaultContext.Get(Isolate);
v8::Context::Scope ContextScope(Context);
auto LocalRequire = Require.Get(Isolate);
if (!BindInfoPtr)
{
FBindInfo BindInfo;
BindInfo.Name = *ModuleName;
BindInfo.Prototype.Reset(Isolate, v8::Object::New(Isolate));
BindInfo.InjectNotFinished = true;
BindInfoMap.Emplace(TypeScriptGeneratedClass, std::move(BindInfo));
}
v8::TryCatch TryCatch(Isolate);
v8::Local<v8::Value> Args[] = {FV8Utils::ToV8String(Isolate, ModuleName)};
auto MaybeRet = LocalRequire->Call(Context, v8::Undefined(Isolate), 1, Args);
if (TryCatch.HasCaught())
{
Logger->Error(FString::Printf(
TEXT("load module [%s] exception %s"), *ModuleName, *FV8Utils::TryCatchToString(Isolate, &TryCatch)));
return;
}
if (!MaybeRet.IsEmpty())
{
auto Ret = MaybeRet.ToLocalChecked().As<v8::Object>();
auto MaybeFunc = Ret->Get(Context, FV8Utils::ToV8String(Isolate, "default"));
v8::Local<v8::Value> Val;
if (MaybeFunc.ToLocal(&Val) && Val->IsFunction())
{
auto Func = Val.As<v8::Function>();
v8::Local<v8::Value> VProto;
// UE_LOG(LogTemp, Error, TEXT("found function for , %s"), *ModuleName);
if (Func->Get(Context, FV8Utils::ToV8String(Isolate, "prototype")).ToLocal(&VProto) && VProto->IsObject())
{
// UE_LOG(LogTemp, Error, TEXT("found proto for , %s"), *ModuleName);
v8::Local<v8::Object> Proto = VProto.As<v8::Object>();
TypeScriptGeneratedClass->DynamicInvoker = TsDynamicInvoker;
// BindInfo.Prototype.Reset(Isolate, Proto);
TypeScriptGeneratedClass->ClassConstructor = &UTypeScriptGeneratedClass::StaticConstructor;
// BindInfo.Rebind = false;
v8::Local<v8::Value> VCtor;
if (Proto->Get(Context, FV8Utils::ToV8String(Isolate, "Constructor")).ToLocal(&VCtor) &&
VCtor->IsFunction())
{
// UE_LOG(LogTemp, Error, TEXT("found ctor for , %s"), *ModuleName);
BindInfoMap[TypeScriptGeneratedClass].Constructor.Reset(Isolate, VCtor.As<v8::Function>());
// BindInfo.Prototype.Reset(Isolate, Proto);
}
// SysObjectRetainer.Retain(Class);
// implement by js
TypeScriptGeneratedClass->FunctionToRedirect.Empty();
#if !PUERTS_FORCE_CPP_UFUNCTION
auto NetMethods = v8::Object::New(Isolate);
#endif
for (TFieldIterator<UFunction> It(TypeScriptGeneratedClass, EFieldIteratorFlags::ExcludeSuper,
EFieldIteratorFlags::ExcludeDeprecated, EFieldIteratorFlags::ExcludeInterfaces);
It; ++It)
{
UFunction* Function = *It;
auto FunctionFName = Function->GetFName();
FString FunctionName = Function->GetName();
// FString::Printf(TEXT("InpAxisEvt_%s_%s"), *InputAxisName.ToString(), *GetName())
static FString AxisPrefix(TEXT("InpAxisEvt_"));
if (FunctionName.StartsWith(AxisPrefix))
{
auto FunctionNameWithoutPrefix = FunctionName.Mid(AxisPrefix.Len());
int32 SubPos;
if (FunctionNameWithoutPrefix.FindChar('_', SubPos))
{
FunctionName = FunctionNameWithoutPrefix.Mid(0, SubPos);
}
}
static FString ActionPrefix(TEXT("InpActEvt_"));
if (FunctionName.StartsWith(ActionPrefix))
{
auto FunctionNameWithoutPrefix = FunctionName.Mid(ActionPrefix.Len());
int32 SubPos;
if (FunctionNameWithoutPrefix.FindChar('_', SubPos))
{
FunctionName = FunctionNameWithoutPrefix.Mid(0, SubPos);
}
}
auto V8Name = FV8Utils::ToV8String(Isolate, FunctionName);
v8::Local<v8::Object> FuncsObj =
Function->HasAnyFunctionFlags(FUNC_Static) ? static_cast<v8::Local<v8::Object>>(Func) : Proto;
if (!TypeScriptGeneratedClass->FunctionToRedirect.Contains(FunctionFName) &&
FuncsObj->HasOwnProperty(Context, V8Name).ToChecked() &&
(Function->HasAnyFunctionFlags(FUNC_BlueprintEvent)))
{
auto MaybeValue = FuncsObj->Get(Context, V8Name);
if (!MaybeValue.IsEmpty() && MaybeValue.ToLocalChecked()->IsFunction())
{
// Logger->Warn(FString::Printf(TEXT("override: %s:%s"), *TypeScriptGeneratedClass->GetName(),
// *Function->GetName())); UJSGeneratedClass::Override(Isolate, TypeScriptGeneratedClass,
// Function, v8::Local<v8::Function>::Cast(MaybeValue.ToLocalChecked()), DynamicInvoker, false);
auto FuncInfo = TsFunctionMap.Find(Function);
if (!FuncInfo)
{
TsFunctionMap.Add(
Function, {v8::UniquePersistent<v8::Function>(
Isolate, v8::Local<v8::Function>::Cast(MaybeValue.ToLocalChecked())),
std::make_unique<FFunctionTranslator>(Function, false)});
}
else
{
FuncInfo->FunctionTranslator->Init(Function, false);
FuncInfo->JsFunction = v8::UniquePersistent<v8::Function>(
Isolate, v8::Local<v8::Function>::Cast(MaybeValue.ToLocalChecked()));
}
#if !PUERTS_FORCE_CPP_UFUNCTION
if (Function->HasAnyFunctionFlags(FUNC_Net))
{
__USE(NetMethods->Set(Context, V8Name, v8::True(Isolate)));
}
#endif
TypeScriptGeneratedClass->FunctionToRedirect.Add(FunctionFName);
TypeScriptGeneratedClass->RedirectToTypeScript(Function);
}
}
}
TypeScriptGeneratedClass->RedirectedToTypeScript = true;
#if WITH_EDITOR
TypeScriptGeneratedClass->FunctionToRedirectInitialized = true;
#endif
TryReleaseType(TypeScriptGeneratedClass);
auto NativeCtor = GetJsClass(TypeScriptGeneratedClass, Context);
//如果已经有了bindinfoptr(此时forcereinject一定是true),这种情况下prototype是已经设置过了的,因此不用重复设置prototype
if (!(BindInfoPtr && ForceReinject))
{
v8::Local<v8::Value> VNativeProto;
if (NativeCtor->Get(Context, FV8Utils::ToV8String(Isolate, "prototype")).ToLocal(&VNativeProto) &&
VNativeProto->IsObject())
{
//{} -> Native Prototype -> Js Prototype -> Super Prototype
v8::Local<v8::Object> NativeProto = VNativeProto.As<v8::Object>();
__USE(BindInfoMap[TypeScriptGeneratedClass].Prototype.Get(Isolate)->SetPrototype(
Context, NativeProto));
if (SuperClass)
{
__USE(Proto->SetPrototype(Context, BindInfoMap[SuperClass].Prototype.Get(Isolate)));
}
else
{
__USE(Proto->SetPrototype(Context, NativeProto->GetPrototype()));
}
__USE(NativeProto->SetPrototype(Context, Proto));
#if !PUERTS_FORCE_CPP_UFUNCTION
v8::Local<v8::Value> MergeArgs[] = {Proto, NativeProto, NetMethods};
__USE(MergePrototype.Get(Isolate)->Call(Context, v8::Undefined(Isolate), 3, MergeArgs));
#endif
}
else
{
__USE(BindInfoMap[TypeScriptGeneratedClass].Prototype.Get(Isolate)->SetPrototype(Context, Proto));
}
}
if (RebindObject)
{
for (FUEObjectIterator It(TypeScriptGeneratedClass); It; ++It)
{
auto Object = *It;
if (ObjectMap.Find(Object))
continue;
if (Object->GetClass()->GetName().StartsWith(TEXT("REINST_")))
continue; //跳过父类重新编译后临时状态的对象
//在编辑器下重启虚拟机，如果TS带构造函数，不重新执行的话，新虚拟机上逻辑上少执行了逻辑（比如对js对象一些字段的初始化）
//执行的话，对CreateDefaultSubobject这类UE逻辑又不允许执行多次（会崩溃），两者相较取其轻
//后面看是否能参照蓝图的组件初始化进行改造
// TsConstruct(TypeScriptGeneratedClass, Object);
__USE(FindOrAdd(Isolate, Context, Object->GetClass(), Object, true));
}
}
if (TypeScriptGeneratedClass->IsChildOf(UBlueprintFunctionLibrary::StaticClass()))
{
FinishInjection(TypeScriptGeneratedClass);
}
}
}
}
else
{
Logger->Error(FString::Printf(TEXT("module [%s] invalid"), *ModuleName));
}
}
else
{
Logger->Warn(FString::Printf(TEXT("not find module info for [%s]"), *TypeScriptGeneratedClass->GetName()));
}
}
}
#endif
void FJsEnvImpl::JsHotReload(FName ModuleName, const FString& JsSource)
{
#ifdef SINGLE_THREAD_VERIFY
ensureMsgf(BoundThreadId == FPlatformTLS::GetCurrentThreadId(), TEXT("Access by illegal thread!"));
#endif
auto Isolate = MainIsolate;
v8::Isolate::Scope IsolateScope(Isolate);
v8::HandleScope HandleScope(Isolate);
auto Context = DefaultContext.Get(Isolate);
v8::Context::Scope ContextScope(Context);
auto LocalReloadJs = ReloadJs.Get(Isolate);
FString OutPath, OutDebugPath;
if (ModuleLoader->Search(TEXT(""), ModuleName.ToString(), OutPath, OutDebugPath))
{
OutPath = FPaths::ConvertRelativePathToFull(OutPath);
Logger->Info(FString::Printf(TEXT("reload js module [%s]"), *OutPath));
v8::TryCatch TryCatch(Isolate);
v8::Handle<v8::Value> Args[] = {FV8Utils::ToV8String(Isolate, ModuleName), FV8Utils::ToV8String(Isolate, OutPath),
FV8Utils::ToV8String(Isolate, JsSource)};
(void) (LocalReloadJs->Call(Context, v8::Undefined(Isolate), 3, Args));
if (TryCatch.HasCaught())
{
Logger->Error(FString::Printf(TEXT("reload module exception %s"), *FV8Utils::TryCatchToString(Isolate, &TryCatch)));
}
}
else
{
Logger->Warn(FString::Printf(TEXT("not find js module [%s]"), *ModuleName.ToString()));
return;
}
}
void FJsEnvImpl::ReloadModule(FName ModuleName, const FString& JsSource)
{
#ifdef SINGLE_THREAD_VERIFY
ensureMsgf(BoundThreadId == FPlatformTLS::GetCurrentThreadId(), TEXT("Access by illegal thread!"));
#endif
#ifdef THREAD_SAFE
v8::Locker Locker(MainIsolate);
#endif
// Logger->Info(FString::Printf(TEXT("start reload js module [%s]"), *ModuleName.ToString()));
JsHotReload(ModuleName, JsSource);
}
void FJsEnvImpl::ReloadSource(const FString& Path, const std::string& JsSource)
{
#ifdef SINGLE_THREAD_VERIFY
ensureMsgf(BoundThreadId == FPlatformTLS::GetCurrentThreadId(), TEXT("Access by illegal thread!"));
#endif
#ifdef THREAD_SAFE
v8::Locker Locker(MainIsolate);
#endif
auto Isolate = MainIsolate;
v8::Isolate::Scope IsolateScope(Isolate);
v8::HandleScope HandleScope(Isolate);
auto Context = DefaultContext.Get(Isolate);
v8::Context::Scope ContextScope(Context);
auto LocalReloadJs = ReloadJs.Get(Isolate);
Logger->Info(FString::Printf(TEXT("reload js [%s]"), *Path));
v8::TryCatch TryCatch(Isolate);
v8::Handle<v8::Value> Args[] = {
v8::Undefined(Isolate), FV8Utils::ToV8String(Isolate, Path), FV8Utils::ToV8String(Isolate, JsSource.c_str())};
(void) (LocalReloadJs->Call(Context, v8::Undefined(Isolate), 3, Args));
if (TryCatch.HasCaught())
{
Logger->Error(FString::Printf(TEXT("reload module exception %s"), *FV8Utils::TryCatchToString(Isolate, &TryCatch)));
}
}
void FJsEnvImpl::OnSourceLoaded(std::function<void(const FString&)> Callback)
{
OnSourceLoadedCallback = Callback;
}
#if !defined(ENGINE_INDEPENDENT_JSENV)
void FJsEnvImpl::TryBindJs(const class UObjectBase* InObject)
{
UObjectBaseUtility* Object = static_cast<UObjectBaseUtility*>(const_cast<UObjectBase*>(InObject));
const bool IsCDO = Object->HasAnyFlags(RF_ClassDefaultObject | RF_ArchetypeObject);
// if (!Object->HasAnyFlags(RF_ClassDefaultObject | RF_ArchetypeObject))
{
UClass* Class = InObject->GetClass();
auto TypeScriptGeneratedClass = Cast<UTypeScriptGeneratedClass>(Class);
if (UNLIKELY(TypeScriptGeneratedClass))
{
if (UNLIKELY(IsCDO))
{
if (TypeScriptGeneratedClass->IsChildOf(UBlueprintFunctionLibrary::StaticClass()))
{
TypeScriptGeneratedClass->DynamicInvoker = TsDynamicInvoker;
TypeScriptGeneratedClass->ClassConstructor = &UTypeScriptGeneratedClass::StaticConstructor;
for (TFieldIterator<UFunction> FuncIt(TypeScriptGeneratedClass, EFieldIteratorFlags::ExcludeSuper); FuncIt;
++FuncIt)
{
auto Function = *FuncIt;
if (!Function->HasAllFunctionFlags(FUNC_Static) || Function->HasAnyFunctionFlags(FUNC_Native))
{
continue;
}
Function->FunctionFlags |= FUNC_BlueprintCallable | FUNC_BlueprintEvent | FUNC_Public | FUNC_Native;
Function->SetNativeFunc(&UTypeScriptGeneratedClass::execLazyLoadCallJS);
TypeScriptGeneratedClass->AddNativeFunction(
*Function->GetName(), &UTypeScriptGeneratedClass::execLazyLoadCallJS);
}
}
else
{
// MakeSureInject(TypeScriptGeneratedClass, true, true);
TypeScriptGeneratedClass->DynamicInvoker = TsDynamicInvoker;
TypeScriptGeneratedClass->ClassConstructor = &UTypeScriptGeneratedClass::StaticConstructor;
if (IsInGameThread())
{
// 其实目前在编辑器下Start后才启动虚拟机，这部分本来防止蓝图刷新的代码其实用不上了
auto BindInfoPtr = BindInfoMap.Find(TypeScriptGeneratedClass);
if (BindInfoPtr)
{
BindInfoPtr->InjectNotFinished = true; // CDO construct meat first load or recompiled
}
}
}
}
}
else if (UNLIKELY(!IsCDO && Class == UTypeScriptGeneratedClass::StaticClass()))
{
TypeScriptGeneratedClass = static_cast<UTypeScriptGeneratedClass*>(Object);
TypeScriptGeneratedClass->DynamicInvoker = TsDynamicInvoker;
TypeScriptGeneratedClass->ClassConstructor = &UTypeScriptGeneratedClass::StaticConstructor;
if (IsInGameThread())
{
auto BindInfoPtr = BindInfoMap.Find(TypeScriptGeneratedClass);
if (BindInfoPtr)
{
BindInfoPtr->InjectNotFinished = true; // CDO construct meat first load or recompiled
}
}
}
}
}
void FJsEnvImpl::RebindJs()
{
#ifdef THREAD_SAFE
v8::Locker Locker(MainIsolate);
#endif
for (TObjectIterator<UClass> It; It; ++It)
{
UClass* Class = *It;
if (!Class->IsNative())
{
if (auto TsClass = Cast<UTypeScriptGeneratedClass>(Class))
{
if (!TsClass->NotSupportInject())
{
#if WITH_EDITOR
if (TsClass->FunctionToRedirectInitialized && !TsClass->IsChildOf(UBlueprintFunctionLibrary::StaticClass()))
{
TsClass->DynamicInvoker = TsDynamicInvoker;
TsClass->ClassConstructor = &UTypeScriptGeneratedClass::StaticConstructor;
TsClass->NeedReBind = true;
TsClass->GeneratedObjects.Empty(TsClass->GeneratedObjects.Num());
TsClass->LazyLoadRedirect();
}
else
#endif
{
MakeSureInject(TsClass, false, true);
FinishInjection(TsClass);
}
}
}
else
{
auto IsTsSubclass = [](UClass* InnerClass)
{
while (InnerClass)
{
if (InnerClass->ClassConstructor == UTypeScriptGeneratedClass::StaticConstructor ||
Cast<UTypeScriptGeneratedClass>(InnerClass))
return true;
InnerClass = InnerClass->GetSuperClass();
}
return false;
};
if (IsTsSubclass(Class))
{
Class->ClassConstructor = UTypeScriptGeneratedClass::StaticConstructor;
}
}
}
}
//如果在notifyrebind的时候去遍历,那么多次遍历会明显拉低性能
//改为rebindjs的时候一次性找到全部需要rebind的object
//在遍历之后创建的uobject,虽然不会被GeneratedObjects记录,但是因为会走TypeScript::ObjectInialize,所以也不用担心没有被bind
#if WITH_EDITOR
for (TObjectIterator<UObject> It; It; ++It)
{
if (It->GetClass()->ClassConstructor == UTypeScriptGeneratedClass::StaticConstructor)
{
UClass* Cls = It->GetClass();
while (Cls)
{
if (Cast<UTypeScriptGeneratedClass>(Cls))
break;
Cls = Cls->GetSuperClass();
}
while (Cls)
{
if (UTypeScriptGeneratedClass* TsClass = Cast<UTypeScriptGeneratedClass>(Cls))
{
TsClass->GeneratedObjects.Add(*It);
Cls = Cls->GetSuperClass();
}
else
{
break;
}
}
}
}
#endif
}
#endif
FString FJsEnvImpl::CurrentStackTrace()
{
#ifndef WITH_QUICKJS
v8::Isolate* Isolate = MainIsolate;
#ifdef THREAD_SAFE
v8::Locker Locker(Isolate);
#endif
v8::Isolate::Scope IsolateScope(Isolate);
v8::HandleScope HandleScope(Isolate);
std::string StackTrace = StackTraceToString(Isolate, v8::StackTrace::CurrentStackTrace(Isolate, 10, v8::StackTrace::kDetailed));
return UTF8_TO_TCHAR(StackTrace.c_str());
#else
return TEXT("");
#endif
}
bool FJsEnvImpl::IsTypeScriptGeneratedClass(UClass* Class)
{
while (Class)
{
if (Class->GetClass() == UTypeScriptGeneratedClass::StaticClass())
{
return true;
}
Class = Class->GetSuperClass();
}
return false;
}
void FJsEnvImpl::Bind(FClassWrapper* ClassWrapper, UObject* UEObject,
v8::Local<v8::Object> JSObject) // Just call in FClassReflection::Call, new a Object
{
#if PUERTS_KEEP_UOBJECT_REFERENCE
const bool IsNativeTakeJsRef = ClassWrapper->IsNativeTakeJsRef;
#else
const bool ClassWrapperIsNativeTakeJsRef = ClassWrapper->IsNativeTakeJsRef; //这个值只有mixin会进行设置
const bool IsUClass = UEObject->IsA<UClass>();
const bool IsCDO = UEObject->HasAnyFlags(RF_ClassDefaultObject | RF_ArchetypeObject);
const bool IsNativeTakeJsRef = (IsCDO || IsUClass) ? false : ClassWrapperIsNativeTakeJsRef;
#endif
DataTransfer::SetPointer(MainIsolate, JSObject, UEObject, 0);
DataTransfer::SetPointer(MainIsolate, JSObject, nullptr, 1);
ObjectMap.Emplace(UEObject, v8::UniquePersistent<v8::Value>(MainIsolate, JSObject));
if (!IsNativeTakeJsRef)
{
SetJsTakeRef(UEObject, ClassWrapper);
}
}
void FJsEnvImpl::SetJsTakeRef(UObject* UEObject, FClassWrapper* ClassWrapper)
{
UserObjectRetainer.Retain(UEObject);
ObjectMap[UEObject].SetWeak<UClass>(
Cast<UClass>(ClassWrapper->Struct.Get()), FClassWrapper::OnGarbageCollected, v8::WeakCallbackType::kInternalFields);
}
void FJsEnvImpl::UnBind(UClass* Class, UObject* UEObject, bool ResetPointer)
{
auto PersistentValuePtr = ObjectMap.Find(UEObject);
if (PersistentValuePtr)
{
if (ResetPointer)
{
auto Isolate = MainIsolate;
v8::Isolate::Scope IsolateScope(Isolate);
v8::HandleScope HandleScope(Isolate);
auto Context = DefaultContext.Get(Isolate);
v8::Context::Scope ContextScope(Context);
auto JsObject = PersistentValuePtr->Get(Isolate).As<v8::Object>();
DataTransfer::SetPointer(MainIsolate, JsObject, RELEASED_UOBJECT, 0);
DataTransfer::SetPointer(Isolate, JsObject, nullptr, 1);
}
ObjectMap.Remove(UEObject);
UserObjectRetainer.Release(UEObject);
}
}
void FJsEnvImpl::UnBind(UClass* Class, UObject* UEObject)
{
UnBind(Class, UEObject, false);
}
v8::Local<v8::Value> FJsEnvImpl::FindOrAdd(
v8::Isolate* Isolate, v8::Local<v8::Context>& Context, UClass* Class, UObject* UEObject, bool SkipTypeScriptInitial)
{
if (!UEObject)
{
return v8::Null(Isolate);
}
auto PersistentValuePtr = ObjectMap.Find(UEObject);
if (!PersistentValuePtr) // create and link
{
bool Existed;
auto TemplateInfoPtr = GetTemplateInfoOfType(Class, Existed);
auto Result = TemplateInfoPtr->Template.Get(Isolate)->InstanceTemplate()->NewInstance(Context).ToLocalChecked();
auto ClassWrapper = static_cast<FClassWrapper*>(TemplateInfoPtr->StructWrapper.get());
Bind(ClassWrapper, UEObject, Result);
if (!SkipTypeScriptInitial && ClassWrapper->IsTypeScriptGeneratedClass)
{
TypeScriptInitial(UEObject->GetClass(), UEObject);
}
return Result;
}
else
{
return v8::Local<v8::Value>::New(Isolate, *PersistentValuePtr);
}
}
v8::Local<v8::Value> FJsEnvImpl::FindOrAdd(v8::Isolate* Isolate, v8::Local<v8::Context>& Context, UClass* Class, UObject* UEObject)
{
return FindOrAdd(Isolate, Context, Class, UEObject, false);
}
v8::Local<v8::Value> FJsEnvImpl::FindOrAddStruct(
v8::Isolate* Isolate, v8::Local<v8::Context>& Context, UScriptStruct* ScriptStruct, void* Ptr, bool PassByPointer)
{
if (!Ptr)
{
return v8::Null(Isolate);
}
auto HeaderPtr = StructCache.Find(Ptr);
if (HeaderPtr)
{
auto CacheNodePtr = HeaderPtr->Find(ScriptStruct);
if (CacheNodePtr)
{
return CacheNodePtr->Value.Get(Isolate);
}
}
// create and link
bool Existed;
auto TemplateInfoPtr = GetTemplateInfoOfType(ScriptStruct, Existed);
auto Result = TemplateInfoPtr->Template.Get(Isolate)->InstanceTemplate()->NewInstance(Context).ToLocalChecked();
BindStruct(static_cast<FScriptStructWrapper*>(TemplateInfoPtr->StructWrapper.get()), Ptr, Result, PassByPointer);
return Result;
}
v8::Local<v8::Value> FJsEnvImpl::FindOrAddCppObject(
v8::Isolate* Isolate, v8::Local<v8::Context>& Context, const void* TypeId, void* Ptr, bool PassByPointer)
{
return CppObjectMapper.FindOrAddCppObject(Isolate, Context, TypeId, Ptr, PassByPointer);
}
v8::Local<v8::Value> FJsEnvImpl::FindOrAddDelegate(v8::Isolate* Isolate, v8::Local<v8::Context>& Context, UObject* Owner,
PropertyMacro* Property, void* DelegatePtr, bool PassByPointer)
{
check(DelegatePtr); // must not null
if (PassByPointer)
{
auto Iter = DelegateMap.find(DelegatePtr);
if (Iter != DelegateMap.end())
{
if (Iter->second.Owner.IsValid())
{
return Iter->second.JSObject.Get(Isolate);
}
else
{
ClearDelegate(Isolate, Context, DelegatePtr);
}
}
}
else
{
if (CastFieldMacro<DelegatePropertyMacro>(Property))
{
auto NewDelegatePtr = new FScriptDelegate;
*NewDelegatePtr = *static_cast<FScriptDelegate*>(DelegatePtr);
DelegatePtr = NewDelegatePtr;
}
else // do not support MulticastDelegate
{
return v8::Undefined(Isolate);
}
}
{
// UE_LOG(LogTemp, Warning, TEXT("FindOrAddDelegate -- new %s"), *Property->GetName());
auto Constructor = (Property->IsA<DelegatePropertyMacro>() ? DelegateTemplate : MulticastDelegateTemplate)
.Get(Isolate)
->GetFunction(Context)
.ToLocalChecked();
auto JSObject = Constructor->NewInstance(Context).ToLocalChecked();
DataTransfer::SetPointer(Isolate, JSObject, DelegatePtr, 0);
(void) (JSObject->Set(Context, 0, v8::Map::New(Isolate)));
UFunction* Function = nullptr;
DelegatePropertyMacro* DelegateProperty = CastFieldMacro<DelegatePropertyMacro>(Property);
MulticastDelegatePropertyMacro* MulticastDelegateProperty = CastFieldMacro<MulticastDelegatePropertyMacro>(Property);
if (DelegateProperty)
{
Function = DelegateProperty->SignatureFunction;
}
else if (MulticastDelegateProperty)
{
Function = MulticastDelegateProperty->SignatureFunction;
}
DelegateMap[DelegatePtr] = {v8::UniquePersistent<v8::Object>(Isolate, JSObject), TWeakObjectPtr<UObject>(Owner),
DelegateProperty, MulticastDelegateProperty, Function, PassByPointer, nullptr,
v8::UniquePersistent<v8::Array>(Isolate, v8::Array::New(Isolate))};
return JSObject;
}
}
v8::Local<v8::Value> FJsEnvImpl::CreateArray(
v8::Isolate* Isolate, v8::Local<v8::Context>& Context, FPropertyTranslator* Property, void* ArrayPtr)
{
auto Array = FixSizeArrayTemplate.Get(Isolate)->GetFunction(Context).ToLocalChecked()->NewInstance(Context).ToLocalChecked();
DataTransfer::SetPointer(Isolate, Array, ArrayPtr, 0);
DataTransfer::SetPointer(Isolate, Array, Property, 1);
return Array;
}
void FJsEnvImpl::InvokeDelegateCallback(UDynamicDelegateProxy* Proxy, void* Params)
{
#ifdef SINGLE_THREAD_VERIFY
ensureMsgf(BoundThreadId == FPlatformTLS::GetCurrentThreadId(), TEXT("Access by illegal thread!"));
#endif
auto SignatureFunction = Proxy->SignatureFunction;
auto Iter = JsCallbackPrototypeMap.find(SignatureFunction.Get());
if (Iter == JsCallbackPrototypeMap.end())
{
if (!SignatureFunction.IsValid())
{
Logger->Warn(TEXT("invalid SignatureFunction!"));
return;
}
JsCallbackPrototypeMap[SignatureFunction.Get()] = std::make_unique<FFunctionTranslator>(SignatureFunction.Get(), true);
Iter = JsCallbackPrototypeMap.find(SignatureFunction.Get());
}
else
{
if (!SignatureFunction.IsValid())
{
JsCallbackPrototypeMap.erase(Iter);
Logger->Warn(TEXT("invalid SignatureFunction!"));
return;
}
// 非 Editor 模式，函数签名地址可能会变且内存可能复用，不检查可能会访问到旧的非法地址。
if (!Iter->second->IsValid())
{
JsCallbackPrototypeMap[SignatureFunction.Get()] = std::make_unique<FFunctionTranslator>(SignatureFunction.Get(), true);
Iter = JsCallbackPrototypeMap.find(SignatureFunction.Get());
}
}
auto Isolate = MainIsolate;
v8::Isolate::Scope IsolateScope(Isolate);
v8::HandleScope HandleScope(Isolate);
auto Context = DefaultContext.Get(Isolate);
v8::Context::Scope ContextScope(Context);
v8::TryCatch TryCatch(Isolate);
Iter->second->CallJs(Isolate, Context, Proxy->JsFunction.Get(Isolate), Context->Global(), Params);
if (TryCatch.HasCaught())
{
Logger->Error(FString::Printf(TEXT("js callback exception %s"), *FV8Utils::TryCatchToString(Isolate, &TryCatch)));
}
}
#if !defined(ENGINE_INDEPENDENT_JSENV)
void FJsEnvImpl::JsConstruct(UClass* Class, UObject* Object, const v8::UniquePersistent<v8::Function>& Constructor,
const v8::UniquePersistent<v8::Object>& Prototype)
{
#ifdef SINGLE_THREAD_VERIFY
ensureMsgf(BoundThreadId == FPlatformTLS::GetCurrentThreadId(), TEXT("Access by illegal thread!"));
#endif
auto Isolate = MainIsolate;
v8::Isolate::Scope IsolateScope(Isolate);
v8::HandleScope HandleScope(Isolate);
auto Context = DefaultContext.Get(Isolate);
v8::Context::Scope ContextScope(Context);
v8::TryCatch TryCatch(Isolate);
auto JSObject = FindOrAdd(Isolate, Context, Class, Object)->ToObject(Context).ToLocalChecked();
// 过时功能(makeUClass)用不影响现有功能的方式修改
UnBind(Class, Object);
ObjectMap.Emplace(Object, v8::UniquePersistent<v8::Value>(MainIsolate, JSObject));
if (!Prototype.IsEmpty())
{
(void) (JSObject->SetPrototype(Context, Prototype.Get(Isolate)));
}
if (!Constructor.IsEmpty())
{
(void) (Constructor.Get(Isolate)->Call(Context, JSObject, 0, nullptr));
}
if (TryCatch.HasCaught())
{
Logger->Error(FString::Printf(TEXT("js callback exception %s"), *FV8Utils::TryCatchToString(Isolate, &TryCatch)));
}
}
void FJsEnvImpl::TsConstruct(UTypeScriptGeneratedClass* Class, UObject* Object)
{
#ifdef THREAD_SAFE
v8::Locker Locker(MainIsolate);
#else
if (!IsInGameThread())
{
Logger->Error(FString::Printf(TEXT("Construct TypeScript Object %s(%p) on illegal thread!"), *Object->GetName(), Object));
}
#endif
#ifdef SINGLE_THREAD_VERIFY
ensureMsgf(BoundThreadId == FPlatformTLS::GetCurrentThreadId(), TEXT("Access by illegal thread!"));
#endif
bool IsCDO = Object->HasAnyFlags(RF_ClassDefaultObject | RF_ArchetypeObject);
UObject* CDO = Class->GetDefaultObject(false);
if (CDO != Object && IsCDO) // blueprint extend a ts
{
UClass* ObjClass = Object->GetClass();
while (ObjClass && !ObjClass->IsNative() && !static_cast<UObject*>(ObjClass)->IsA<UTypeScriptGeneratedClass>())
{
// Logger->Warn(FString::Printf(TEXT("release %s in %s(%p) construct"), *ObjClass->GetName(), *Object->GetName(),
// Object));
TryReleaseType(ObjClass);
ObjClass = ObjClass->GetSuperClass();
}
}
auto BindInfoPtr = BindInfoMap.Find(Class);
if (!BindInfoPtr || BindInfoPtr->InjectNotFinished)
{
// Logger->Warn(FString::Printf(TEXT("force %s injection in %s(%p) construct"), *Class->GetName(), *Object->GetName(),
// Object));
MakeSureInject(Class, true, false);
if (!IsCDO) // finish inject in first non-CDO construct
{
// Logger->Warn(FString::Printf(TEXT("finish %s injection in %s(%p) construct"), *Class->GetName(), *Object->GetName(),
// Object));
FinishInjection(Class);
}
BindInfoPtr = BindInfoMap.Find(Class);
}
if (BindInfoPtr)
{
auto Isolate = MainIsolate;
v8::Isolate::Scope IsolateScope(Isolate);
v8::HandleScope HandleScope(Isolate);
auto Context = DefaultContext.Get(Isolate);
v8::Context::Scope ContextScope(Context);
v8::TryCatch TryCatch(Isolate);
v8::Local<v8::Object> JSObject;
auto PersistentValuePtr = ObjectMap.Find(Object);
if (!PersistentValuePtr)
{
JSObject = FindOrAdd(Isolate, Context, Object->GetClass(), Object, true)->ToObject(Context).ToLocalChecked();
// FindOrAdd may change BindInfoMap, cause a rehash
BindInfoPtr = BindInfoMap.Find(Class);
}
else
{
JSObject = PersistentValuePtr->Get(Isolate).As<v8::Object>();
}
//假如是UTypeScriptGeneratedClass的对象，设置成间接Prototype，后续刷新代码对象会自动更新
if (Object->GetClass() == Class && !BindInfoPtr->Prototype.IsEmpty())
{
__USE(JSObject->SetPrototype(Context, BindInfoPtr->Prototype.Get(Isolate)));
}
if (!BindInfoPtr->Constructor.IsEmpty())
{
__USE(BindInfoPtr->Constructor.Get(Isolate)->Call(Context, JSObject, 0, nullptr));
}
if (TryCatch.HasCaught())
{
Logger->Error(FString::Printf(TEXT("js callback exception %s"), *FV8Utils::TryCatchToString(Isolate, &TryCatch)));
}
}
else if (!Object->HasAnyFlags(RF_ClassDefaultObject | RF_ArchetypeObject))
{
Logger->Error(FString::Printf(TEXT("Construct TypeScript Object fail for %s"), *Class->GetName()));
}
}
#endif
void FJsEnvImpl::NotifyUObjectDeleted(const class UObjectBase* ObjectBase, int32 Index)
{
#ifdef SINGLE_THREAD_VERIFY
ensureMsgf(BoundThreadId == FPlatformTLS::GetCurrentThreadId(), TEXT("Access by illegal thread!"));
#endif
#ifdef THREAD_SAFE
v8::Locker Locker(MainIsolate);
#endif
TryReleaseType((UStruct*) ObjectBase);
#if !defined(ENGINE_INDEPENDENT_JSENV)
BindInfoMap.Remove((UTypeScriptGeneratedClass*) ObjectBase);
#endif
UnBind(nullptr, (UObject*) ObjectBase, true);
GeneratedClasses.Remove((UClass*) ObjectBase);
TsFunctionMap.Remove((UFunction*) ObjectBase);
MixinFunctionMap.Remove((UFunction*) ObjectBase);
ContainerMeta.NotifyElementTypeDeleted((UField*) ObjectBase);
auto CallbacksPtr = AutoReleaseCallbacksMap.Find((UObject*) ObjectBase);
if (CallbacksPtr)
{
for (auto Callback : *CallbacksPtr)
{
if (Callback.IsValid())
{
Callback.Get()->JsFunction.Reset();
}
SysObjectRetainer.Release(Callback.Get());
}
AutoReleaseCallbacksMap.Remove((UObject*) ObjectBase);
}
}
void FJsEnvImpl::TryReleaseType(UStruct* Struct)
{
TypeToTemplateInfoMap.Remove(Struct);
}
// fix ScriptCore.cpp UObject::SkipFunction crash when Function has no parameters
static void SkipFunction(FFrame& Stack, RESULT_DECL, UFunction* Function)
{
uint8* Frame = (uint8*) FMemory_Alloca(Function->PropertiesSize);
FMemory::Memzero(Frame, Function->PropertiesSize);
for (PropertyMacro* Property = (PropertyMacro*) (
#if ENGINE_MINOR_VERSION >= 25 || ENGINE_MAJOR_VERSION > 4
Function->ChildProperties
#else
Function->Children
#endif
);
Property && (*Stack.Code != EX_EndFunctionParms); Property = (PropertyMacro*) (Property->Next))
{
Stack.MostRecentPropertyAddress = NULL;
Stack.Step(Stack.Object, (Property->PropertyFlags & CPF_OutParm) ? NULL : Property->ContainerPtrToValuePtr<uint8>(Frame));
}
Stack.Code++;
for (PropertyMacro* Destruct = Function->DestructorLink; Destruct; Destruct = Destruct->DestructorLinkNext)
{
if (!Destruct->HasAnyPropertyFlags(CPF_OutParm))
{
Destruct->DestroyValue_InContainer(Frame);
}
}
PropertyMacro* ReturnProp = Function->GetReturnProperty();
if (ReturnProp != NULL)
{
ReturnProp->DestroyValue(RESULT_PARAM);
FMemory::Memzero(RESULT_PARAM, ReturnProp->ArrayDim * ReturnProp->ElementSize);
}
}
#if !defined(ENGINE_INDEPENDENT_JSENV)
void FJsEnvImpl::InvokeJsMethod(UObject* ContextObject, UJSGeneratedFunction* Function, FFrame& Stack, void* RESULT_PARAM)
{
#ifdef SINGLE_THREAD_VERIFY
ensureMsgf(BoundThreadId == FPlatformTLS::GetCurrentThreadId(), TEXT("Access by illegal thread!"));
#endif
auto Isolate = MainIsolate;
#ifdef THREAD_SAFE
v8::Locker Locker(Isolate);
#endif
v8::Isolate::Scope IsolateScope(Isolate);
v8::HandleScope HandleScope(Isolate);
auto Context = DefaultContext.Get(Isolate);
v8::Context::Scope ContextScope(Context);
v8::Local<v8::Value> Self;
auto GeneratedObjectPtr = ObjectMap.Find(ContextObject);
if (GeneratedObjectPtr)
{
Self = GeneratedObjectPtr->Get(Isolate);
}
if (Self.IsEmpty())
{
Logger->Error(FString::Printf(TEXT("call %s::%s of %p fail: can not find Binded JavaScript Object"),
*ContextObject->GetClass()->GetName(), *Function->GetName(), ContextObject));
SkipFunction(Stack, RESULT_PARAM, Function);
return;
}
v8::TryCatch TryCatch(Isolate);
Function->FunctionTranslator->CallJs(
Isolate, Context, Function->JsFunction.Get(Isolate), Self, ContextObject, Stack, RESULT_PARAM);
if (TryCatch.HasCaught())
{
Logger->Error(FString::Printf(TEXT("call %s::%s of %p fail: %s"), *ContextObject->GetClass()->GetName(),
*Function->GetName(), ContextObject, *FV8Utils::TryCatchToString(Isolate, &TryCatch)));
}
}
void FJsEnvImpl::InvokeMixinMethod(UObject* ContextObject, UJSGeneratedFunction* Function, FFrame& Stack, void* RESULT_PARAM)
{
#ifdef SINGLE_THREAD_VERIFY
ensureMsgf(BoundThreadId == FPlatformTLS::GetCurrentThreadId(), TEXT("Access by illegal thread!"));
#endif
auto Isolate = MainIsolate;
#ifdef THREAD_SAFE
v8::Locker Locker(Isolate);
#endif
v8::Isolate::Scope IsolateScope(Isolate);
v8::HandleScope HandleScope(Isolate);
auto Context = DefaultContext.Get(Isolate);
v8::Context::Scope ContextScope(Context);
v8::Local<v8::Value> Self = FindOrAdd(Isolate, Context, ContextObject->GetClass(), ContextObject);
auto JsFuncPtr = MixinFunctionMap.Find(Function);
if (!JsFuncPtr)
{
Logger->Error(FString::Printf(TEXT("call %s::%s of %p fail: can not find Binded JavaScript Function"),
*ContextObject->GetClass()->GetName(), *Function->GetName(), ContextObject));
SkipFunction(Stack, RESULT_PARAM, Function);
return;
}
v8::TryCatch TryCatch(Isolate);
Function->FunctionTranslator->CallJs(Isolate, Context, JsFuncPtr->Get(Isolate), Self, ContextObject, Stack, RESULT_PARAM);
if (TryCatch.HasCaught())
{
Logger->Error(FString::Printf(TEXT("call %s::%s of %p fail: %s"), *ContextObject->GetClass()->GetName(),
*Function->GetName(), ContextObject, *FV8Utils::TryCatchToString(Isolate, &TryCatch)));
}
}
void FJsEnvImpl::TypeScriptInitial(UClass* Class, UObject* Object, const bool TypeScriptClassFound)
{
if (auto TypeScriptGeneratedClass = Cast<UTypeScriptGeneratedClass>(Class))
{
TypeScriptInitial(Class->GetSuperClass(), Object, true);
TsConstruct(TypeScriptGeneratedClass, Object);
}
else if (!TypeScriptClassFound)
{
TypeScriptInitial(Class->GetSuperClass(), Object, false);
}
}
void FJsEnvImpl::InvokeTsMethod(UObject* ContextObject, UFunction* Function, FFrame& Stack, void* RESULT_PARAM)
{
#ifdef SINGLE_THREAD_VERIFY
ensureMsgf(BoundThreadId == FPlatformTLS::GetCurrentThreadId(), TEXT("Access by illegal thread!"));
#endif
#ifdef THREAD_SAFE
v8::Locker Locker(MainIsolate);
#endif
auto FuncInfo = TsFunctionMap.Find(Function);
if (!FuncInfo)
{
auto Class = Cast<UTypeScriptGeneratedClass>(Function->GetOuterUClassUnchecked());
MakeSureInject(Class, true, false);
FinishInjection(Class);
FuncInfo = TsFunctionMap.Find(Function);
if (!FuncInfo)
{
Logger->Error(FString::Printf(TEXT("call %s::%s of %p fail: can not find Binded JavaScript Function"),
*ContextObject->GetClass()->GetName(), *Function->GetName(), ContextObject));
SkipFunction(Stack, RESULT_PARAM, Function);
return;
}
}
{
auto Isolate = MainIsolate;
v8::Isolate::Scope IsolateScope(Isolate);
v8::HandleScope HandleScope(Isolate);
auto Context = DefaultContext.Get(Isolate);
v8::Context::Scope ContextScope(Context);
v8::Local<v8::Value> ThisObj = v8::Undefined(Isolate);
if (!Function->HasAnyFunctionFlags(FUNC_Static))
{
ThisObj = FindOrAdd(Isolate, Context, ContextObject->GetClass(), ContextObject);
}
v8::TryCatch TryCatch(Isolate);
FuncInfo->FunctionTranslator->CallJs(
Isolate, Context, FuncInfo->JsFunction.Get(Isolate), ThisObj, ContextObject, Stack, RESULT_PARAM);
if (TryCatch.HasCaught())
{
Logger->Error(FString::Printf(TEXT("call %s::%s of %p fail: %s"), *ContextObject->GetClass()->GetName(),
*Function->GetName(), ContextObject, *FV8Utils::TryCatchToString(Isolate, &TryCatch)));
}
}
}
void FJsEnvImpl::NotifyReBind(UTypeScriptGeneratedClass* Class)
{
auto Isolate = MainIsolate;
#ifdef THREAD_SAFE
v8::Locker Locker(Isolate);
#endif
MakeSureInject(Class, false, false);
FinishInjection(Class);
#if WITH_EDITOR
while (UTypeScriptGeneratedClass* SuperCls = Cast<UTypeScriptGeneratedClass>(Class->GetSuperClass()))
{
Class = SuperCls;
}
{
v8::Isolate::Scope IsolateScope(Isolate);
v8::HandleScope HandleScope(Isolate);
auto Context = DefaultContext.Get(Isolate);
v8::Context::Scope ContextScope(Context);
for (TWeakObjectPtr<UObject>& Iter : Class->GeneratedObjects)
{
auto Object = Iter.Get();
if (!Object || ObjectMap.Find(Object))
continue;
if (Object->GetClass()->GetName().StartsWith(TEXT("REINST_")))
continue; //跳过父类重新编译后临时状态的对象
__USE(FindOrAdd(Isolate, Context, Object->GetClass(), Object, true));
UTypeScriptGeneratedClass* ClassMayNeedReBind = nullptr;
auto TempClass = Object->GetClass();
while (TempClass && (TempClass != Class) && (!ClassMayNeedReBind))
{
ClassMayNeedReBind = Cast<UTypeScriptGeneratedClass>(TempClass);
TempClass = TempClass->GetSuperClass();
}
if (ClassMayNeedReBind)
{
MakeSureInject(ClassMayNeedReBind, false, false);
}
}
}
#endif
}
#endif
void FJsEnvImpl::ExecuteDelegate(
v8::Isolate* Isolate, v8::Local<v8::Context>& Context, const v8::FunctionCallbackInfo<v8::Value>& Info, void* DelegatePtr)
{
auto Iter = DelegateMap.find(DelegatePtr);
if (Iter == DelegateMap.end())
{
FV8Utils::ThrowException(Isolate, "can not find the delegate!");
}
auto SignatureFunction = Iter->second.SignatureFunction;
if (JsCallbackPrototypeMap.find(SignatureFunction) == JsCallbackPrototypeMap.end())
{
JsCallbackPrototypeMap[SignatureFunction] = std::make_unique<FFunctionTranslator>(SignatureFunction, true);
}
if (Iter->second.DelegateProperty)
{
JsCallbackPrototypeMap[SignatureFunction]->Call(Isolate, Context, Info,
[ScriptDelegate = static_cast<FScriptDelegate*>(DelegatePtr)](void* Params)
{ ScriptDelegate->ProcessDelegate<UObject>(Params); });
}
else
{
JsCallbackPrototypeMap[SignatureFunction]->Call(Isolate, Context, Info,
[MulticastScriptDelegate = static_cast<FMulticastScriptDelegate*>(DelegatePtr)](void* Params)
{ MulticastScriptDelegate->ProcessMulticastDelegate<UObject>(Params); });
}
}
static FName NAME_Fire("Fire");
bool FJsEnvImpl::AddToDelegate(
v8::Isolate* Isolate, v8::Local<v8::Context>& Context, void* DelegatePtr, v8::Local<v8::Function> JsFunction)
{
// UE_LOG(LogTemp, Warning, TEXT("add delegate proxy"));
auto Iter = DelegateMap.find(DelegatePtr);
if (Iter == DelegateMap.end())
{
return false;
}
if (!Iter->second.Owner.IsValid())
{
Logger->Warn("try to bind a delegate with invalid owner!");
ClearDelegate(Isolate, Context, DelegatePtr);
if (!Iter->second.PassByPointer)
{
delete ((FScriptDelegate*) Iter->first);
}
DelegateMap.erase(Iter);
return false;
}
auto JsCallbacks = Iter->second.JsCallbacks.Get(Isolate);
UDynamicDelegateProxy* DelegateProxy = nullptr;
bool InitApplyFunc = false;
if (Iter->second.Proxy.IsValid())
{
DelegateProxy = Iter->second.Proxy.Get();
if (Iter->second.DelegateProperty)
{
if (!static_cast<FScriptDelegate*>(DelegatePtr)->IsBoundToObject(DelegateProxy))
{
InitApplyFunc = true;
}
}
else if (Iter->second.MulticastDelegateProperty)
{
#if ENGINE_MINOR_VERSION >= 23 || ENGINE_MAJOR_VERSION > 4
if (Iter->second.MulticastDelegateProperty->IsA<MulticastSparseDelegatePropertyMacro>())
{
if (!FSparseDelegateStorage::Contains(
Iter->second.Owner.Get(), Iter->second.MulticastDelegateProperty->GetFName(), DelegateProxy, NAME_Fire))
{
InitApplyFunc = true;
}
}
else
{
#endif
if (!static_cast<FMulticastScriptDelegate*>(DelegatePtr)->Contains(DelegateProxy, NAME_Fire))
{
InitApplyFunc = true;
}
}
}
if (InitApplyFunc)
{
if (JsCallbacks->Length() > 0)
{
JsCallbacks = v8::Array::New(Isolate);
Iter->second.JsCallbacks.Reset(Isolate, JsCallbacks);
}
else
{
InitApplyFunc = false;
}
}
}
else
{
DelegateProxy = NewObject<UDynamicDelegateProxy>();
#ifdef THREAD_SAFE
DelegateProxy->Isolate = Isolate;
#endif
DelegateProxy->Owner = Iter->second.Owner;
DelegateProxy->SignatureFunction = Iter->second.SignatureFunction;
DelegateProxy->DynamicInvoker = DynamicInvoker;
InitApplyFunc = true;
SysObjectRetainer.Retain(DelegateProxy);
Iter->second.Proxy = DelegateProxy;
}
if (InitApplyFunc)
{
v8::TryCatch TryCatch(Isolate);
v8::Local<v8::Value> Args[] = {JsCallbacks};
v8::Local<v8::Value> Apply;
if (!GenListApply.Get(Isolate)->Call(Context, v8::Undefined(Isolate), 1, Args).ToLocal(&Apply) || !Apply->IsFunction())
{
FString ErrMsg = TEXT("Unknow");
if (TryCatch.HasCaught())
{
ErrMsg = FV8Utils::TryCatchToString(Isolate, &TryCatch);
}
Logger->Error(FString::Printf(TEXT("gen callback apply fail: %s"), *ErrMsg));
return false;
}
DelegateProxy->JsFunction = v8::UniquePersistent<v8::Function>(Isolate, v8::Local<v8::Function>::Cast(Apply));
}
bool bSingleDelegate = Iter->second.DelegateProperty != nullptr;
(void) (JsCallbacks->Set(Context, bSingleDelegate ? 0 : JsCallbacks->Length(), JsFunction)); // push
FScriptDelegate Delegate;
Delegate.BindUFunction(DelegateProxy, NAME_Fire);
if (Iter->second.DelegateProperty)
{
// UE_LOG(LogTemp, Warning, TEXT("bind to delegate"));
*(static_cast<FScriptDelegate*>(DelegatePtr)) = Delegate;
}
else if (Iter->second.MulticastDelegateProperty)
{
// UE_LOG(LogTemp, Warning, TEXT("add to multicast delegate, proxy: %p to:%p"), DelegateProxy, DelegatePtr);
#if ENGINE_MINOR_VERSION >= 23 || ENGINE_MAJOR_VERSION > 4
if (Iter->second.MulticastDelegateProperty->IsA<MulticastSparseDelegatePropertyMacro>())
{
Iter->second.MulticastDelegateProperty->AddDelegate(MoveTemp(Delegate), Iter->second.Owner.Get(), DelegatePtr);
}
else
#endif
{
static_cast<FMulticastScriptDelegate*>(DelegatePtr)->AddUnique(Delegate);
}
}
return true;
}
PropertyMacro* FJsEnvImpl::FindDelegateProperty(void* DelegatePtr)
{
auto Iter = DelegateMap.find(DelegatePtr);
if (Iter == DelegateMap.end())
{
return nullptr;
}
return Iter->second.DelegateProperty ? (PropertyMacro*) Iter->second.DelegateProperty
: (PropertyMacro*) Iter->second.MulticastDelegateProperty;
}
FScriptDelegate FJsEnvImpl::NewDelegate(v8::Isolate* Isolate, v8::Local<v8::Context>& Context, UObject* Owner,
v8::Local<v8::Function> JsFunction, UFunction* SignatureFunction)
{
UDynamicDelegateProxy* DelegateProxy = nullptr;
if (Owner)
{
TArray<TWeakObjectPtr<UDynamicDelegateProxy>>& Callbacks = AutoReleaseCallbacksMap.FindOrAdd(Owner);
DelegateProxy = NewObject<UDynamicDelegateProxy>();
#ifdef THREAD_SAFE
DelegateProxy->Isolate = Isolate;
#endif
DelegateProxy->Owner = Owner;
DelegateProxy->SignatureFunction = SignatureFunction;
DelegateProxy->DynamicInvoker = DynamicInvoker;
DelegateProxy->JsFunction = v8::UniquePersistent<v8::Function>(Isolate, JsFunction);
SysObjectRetainer.Retain(DelegateProxy);
Callbacks.Add(DelegateProxy);
}
else
{
auto CallbacksMap = ManualReleaseCallbackMap.Get(Isolate);
auto MaybeProxy = CallbacksMap->Get(Context, JsFunction);
if (MaybeProxy.IsEmpty() || !MaybeProxy.ToLocalChecked()->IsExternal())
{
DelegateProxy = NewObject<UDynamicDelegateProxy>();
#ifdef THREAD_SAFE
DelegateProxy->Isolate = Isolate;
#endif
DelegateProxy->Owner = DelegateProxy;
DelegateProxy->SignatureFunction = SignatureFunction;
DelegateProxy->DynamicInvoker = DynamicInvoker;
DelegateProxy->JsFunction = v8::UniquePersistent<v8::Function>(Isolate, JsFunction);
SysObjectRetainer.Retain(DelegateProxy);
__USE(CallbacksMap->Set(Context, JsFunction, v8::External::New(Context->GetIsolate(), DelegateProxy)));
ManualReleaseCallbackList.push_back(DelegateProxy);
}
else
{
DelegateProxy = Cast<UDynamicDelegateProxy>(
static_cast<UObject*>(v8::Local<v8::External>::Cast(MaybeProxy.ToLocalChecked())->Value()));
if (DelegateProxy->SignatureFunction.Get() != SignatureFunction)
{
Logger->Error(TEXT("aleady bind to another delegate pleace release first!"));
DelegateProxy = nullptr;
}
}
}
FScriptDelegate Delegate;
if (DelegateProxy)
{
Delegate.BindUFunction(DelegateProxy, NAME_Fire);
}
return Delegate;
}
void FJsEnvImpl::ReleaseManualReleaseDelegate(const v8::FunctionCallbackInfo<v8::Value>& Info)
{
v8::Isolate* Isolate = Info.GetIsolate();
v8::Isolate::Scope IsolateScope(Isolate);
v8::HandleScope HandleScope(Isolate);
v8::Local<v8::Context> Context = Isolate->GetCurrentContext();
v8::Context::Scope ContextScope(Context);
CHECK_V8_ARGS(EArgFunction);
auto CallbacksMap = ManualReleaseCallbackMap.Get(Isolate);
auto MaybeProxy = CallbacksMap->Get(Context, Info[0]);
if (!MaybeProxy.IsEmpty() && MaybeProxy.ToLocalChecked()->IsExternal())
{
__USE(CallbacksMap->Delete(Context, Info[0]));
auto DelegateProxy =
Cast<UDynamicDelegateProxy>(static_cast<UObject*>(v8::Local<v8::External>::Cast(MaybeProxy.ToLocalChecked())->Value()));
for (auto it = ManualReleaseCallbackList.begin(); it != ManualReleaseCallbackList.end();)
{
if (!it->IsValid())
{
it = ManualReleaseCallbackList.erase(it);
}
else if (it->Get() == DelegateProxy)
{
DelegateProxy->JsFunction.Reset();
it = ManualReleaseCallbackList.erase(it);
SysObjectRetainer.Release(DelegateProxy);
}
else
{
++it;
}
}
}
}
bool FJsEnvImpl::RemoveFromDelegate(
v8::Isolate* Isolate, v8::Local<v8::Context>& Context, void* DelegatePtr, v8::Local<v8::Function> JsFunction)
{
auto Iter = DelegateMap.find(DelegatePtr);
if (Iter == DelegateMap.end())
{
return false;
}
FScriptDelegate Delegate;
if (Iter->second.DelegateProperty)
{
return ClearDelegate(Isolate, Context, DelegatePtr);
}
else if (Iter->second.MulticastDelegateProperty)
{
auto JsCallbacks = Iter->second.JsCallbacks.Get(Isolate);
v8::Local<v8::Value> Args[] = {JsCallbacks, JsFunction};
__USE(RemoveListItem.Get(Isolate)->Call(Context, v8::Undefined(Isolate), 2, Args));
if (JsCallbacks->Length() == 0 && Iter->second.Proxy.IsValid())
{
auto DelegateProxy = Iter->second.Proxy.Get();
Delegate.BindUFunction(DelegateProxy, NAME_Fire);
#if ENGINE_MINOR_VERSION >= 23 || ENGINE_MAJOR_VERSION > 4
if (Iter->second.MulticastDelegateProperty->IsA<MulticastSparseDelegatePropertyMacro>())
{
Iter->second.MulticastDelegateProperty->RemoveDelegate(Delegate, Iter->second.Owner.Get(), DelegatePtr);
}
else
#endif
{
static_cast<FMulticastScriptDelegate*>(DelegatePtr)->Remove(Delegate);
}
SysObjectRetainer.Release(DelegateProxy);
DelegateProxy->JsFunction.Reset();
Iter->second.Proxy.Reset();
}
}
return true;
}
bool FJsEnvImpl::ClearDelegate(v8::Isolate* Isolate, v8::Local<v8::Context>& Context, void* DelegatePtr)
{
auto Iter = DelegateMap.find(DelegatePtr);
if (Iter == DelegateMap.end())
{
return false;
}
auto JSObject = Iter->second.JSObject.Get(Isolate);
auto Map = v8::Local<v8::Map>::Cast(JSObject->Get(Context, 0).ToLocalChecked());
Map->Clear();
if (Iter->second.DelegateProperty)
{
if (Iter->second.Owner.IsValid())
{
FScriptDelegate Delegate;
*(static_cast<FScriptDelegate*>(DelegatePtr)) = Delegate;
}
}
else if (Iter->second.MulticastDelegateProperty)
{
if (Iter->second.Owner.IsValid())
{
#if ENGINE_MINOR_VERSION >= 23 || ENGINE_MAJOR_VERSION > 4
if (Iter->second.MulticastDelegateProperty->IsA<MulticastSparseDelegatePropertyMacro>())
{
Iter->second.MulticastDelegateProperty->ClearDelegate(Iter->second.Owner.Get(), DelegatePtr);
}
else
#endif
{
static_cast<FMulticastScriptDelegate*>(DelegatePtr)->Clear();
}
}
}
if (Iter->second.Proxy.IsValid())
{
Iter->second.Proxy->JsFunction.Reset();
SysObjectRetainer.Release(Iter->second.Proxy.Get());
Iter->second.Proxy.Reset();
}
Iter->second.JsCallbacks.Reset(Isolate, v8::Array::New(Isolate));
return true;
}
bool FJsEnvImpl::CheckDelegateProxies(float Tick)
{
#ifdef SINGLE_THREAD_VERIFY
ensureMsgf(BoundThreadId == FPlatformTLS::GetCurrentThreadId(), TEXT("Access by illegal thread!"));
#endif
auto Isolate = MainIsolate;
#ifdef THREAD_SAFE
v8::Locker Locker(Isolate);
#endif
std::vector<void*> PendingToRemove;
for (auto& KV : DelegateMap)
{
if (!KV.second.Owner.IsValid())
{
PendingToRemove.push_back(KV.first);
}
}
if (PendingToRemove.size() > 0)
{
v8::Isolate::Scope IsolateScope(Isolate);
v8::HandleScope HandleScope(Isolate);
v8::Local<v8::Context> Context = DefaultContext.Get(Isolate);
v8::Context::Scope ContextScope(Context);
for (int i = 0; i < PendingToRemove.size(); ++i)
{
ClearDelegate(Isolate, Context, PendingToRemove[i]);
if (!DelegateMap[PendingToRemove[i]].PassByPointer)
{
delete ((FScriptDelegate*) PendingToRemove[i]);
}
DelegateMap.erase(PendingToRemove[i]);
}
}
// Collecting invalid function translators to remove.
std::vector<UFunction*> PendingToRemoveJsCallbacks;
for (auto& KV : JsCallbackPrototypeMap)
{
if ((nullptr == KV.first) || (!KV.second->IsValid()))
{
PendingToRemoveJsCallbacks.push_back(KV.first);
}
}
if (PendingToRemoveJsCallbacks.size() > 0)
{
for (int32 i = 0; i < PendingToRemoveJsCallbacks.size(); i++)
{
JsCallbackPrototypeMap.erase(PendingToRemoveJsCallbacks[i]);
}
}
return true;
}
FPropertyTranslator* FJsEnvImpl::GetContainerPropertyTranslator(PropertyMacro* Property)
{
auto Iter = ContainerPropertyMap.find(Property);
// TODO: 如果脚本一直持有蓝图里头的Map，还是有可能有问题的，需要统筹考虑一套机制解决这类问题
if (Iter == ContainerPropertyMap.end() || !Iter->second.PropertyWeakPtr.IsValid())
{
ContainerPropertyInfo Temp{Property, FPropertyTranslator::Create(Property)};
ContainerPropertyMap[Property] = std::move(Temp);
#if ENGINE_MINOR_VERSION < 25 && ENGINE_MAJOR_VERSION < 5
if (!Property->IsNative())
{
SysObjectRetainer.Retain(Property);
}
#endif
return ContainerPropertyMap[Property].PropertyTranslator.get();
}
else
{
return Iter->second.PropertyTranslator.get();
}
}
v8::Local<v8::Value> FJsEnvImpl::FindOrAddContainer(
v8::Isolate* Isolate, v8::Local<v8::Context>& Context, PropertyMacro* Property, FScriptArray* Ptr, bool PassByPointer)
{
check(Ptr); // must not null
auto PersistentValuePtr = ContainerCache.Find(Ptr);
if (PersistentValuePtr)
{
return PersistentValuePtr->Container.Get(Isolate);
}
auto Result = ArrayTemplate.Get(Isolate)->InstanceTemplate()->NewInstance(Context).ToLocalChecked();
BindContainer(Ptr, Result,
PassByPointer ? FScriptArrayWrapper::OnGarbageCollected : FScriptArrayWrapper::OnGarbageCollectedWithFree, PassByPointer,
EArray);
DataTransfer::SetPointer(Isolate, Result, GetContainerPropertyTranslator(Property), 1);
return Result;
}
v8::Local<v8::Value> FJsEnvImpl::FindOrAddContainer(
v8::Isolate* Isolate, v8::Local<v8::Context>& Context, PropertyMacro* Property, FScriptSet* Ptr, bool PassByPointer)
{
check(Ptr); // must not null
auto PersistentValuePtr = ContainerCache.Find(Ptr);
if (PersistentValuePtr)
{
return PersistentValuePtr->Container.Get(Isolate);
}
auto Result = SetTemplate.Get(Isolate)->InstanceTemplate()->NewInstance(Context).ToLocalChecked();
BindContainer(Ptr, Result,
PassByPointer ? FScriptSetWrapper::OnGarbageCollected : FScriptSetWrapper::OnGarbageCollectedWithFree, PassByPointer, ESet);
DataTransfer::SetPointer(Isolate, Result, GetContainerPropertyTranslator(Property), 1);
return Result;
}
v8::Local<v8::Value> FJsEnvImpl::FindOrAddContainer(v8::Isolate* Isolate, v8::Local<v8::Context>& Context,
PropertyMacro* KeyProperty, PropertyMacro* ValueProperty, FScriptMap* Ptr, bool PassByPointer)
{
check(Ptr); // must not null
auto PersistentValuePtr = ContainerCache.Find(Ptr);
if (PersistentValuePtr)
{
return PersistentValuePtr->Container.Get(Isolate);
}
auto Result = MapTemplate.Get(Isolate)->InstanceTemplate()->NewInstance(Context).ToLocalChecked();
BindContainer(Ptr, Result,
PassByPointer ? FScriptMapWrapper::OnGarbageCollected : FScriptMapWrapper::OnGarbageCollectedWithFree, PassByPointer, EMap);
DataTransfer::SetPointer(Isolate, Result, GetContainerPropertyTranslator(KeyProperty), 1);
DataTransfer::SetPointer(Isolate, Result, GetContainerPropertyTranslator(ValueProperty), 2);
return Result;
}
void FJsEnvImpl::BindStruct(
FScriptStructWrapper* ScriptStructWrapper, void* Ptr, v8::Local<v8::Object> JSObject, bool PassByPointer)
{
DataTransfer::SetPointer(MainIsolate, JSObject, Ptr, 0);
DataTransfer::SetPointer(
MainIsolate, JSObject, static_cast<UScriptStruct*>(ScriptStructWrapper->Struct.Get()), 1); // add type info
if (!PassByPointer)
{
// Optimization branch:
// ArrayBuffer will be gced on v8 worker thread
// for pod ustruct it's safe to use it
#if defined(HAS_ARRAYBUFFER_NEW_WITHOUT_STL) || defined(WITH_BACKING_STORE_AUTO_FREE)
bool bStructTriviallyFreed = false;
if (ScriptStructWrapper->Struct.IsValid())
{
UScriptStruct* Struct = Cast<UScriptStruct>(ScriptStructWrapper->Struct.Get());
bStructTriviallyFreed = Struct->StructFlags & EStructFlags::STRUCT_IsPlainOldData;
}
if (bStructTriviallyFreed)
{
#if defined(HAS_ARRAYBUFFER_NEW_WITHOUT_STL)
auto MemoryHolder = v8::ArrayBuffer_New_Without_Stl(
MainIsolate, Ptr, ScriptStructWrapper->Struct->GetStructureSize(),
[](void* Data, size_t Length, void* DeleterData)
{
// TFScriptStructWrapper存放在TypeReflectionMap中，Isolate先Dispose后，对象才跟着销毁
FScriptStructWrapper* StructInfo = static_cast<FScriptStructWrapper*>(DeleterData);
FScriptStructWrapper::Free(StructInfo->Struct, StructInfo->ExternalFinalize, Data);
},
ScriptStructWrapper);
__USE(JSObject->Set(MainIsolate->GetCurrentContext(), 0, MemoryHolder));
return; // early return
#elif WITH_BACKING_STORE_AUTO_FREE
auto Backing = v8::ArrayBuffer::NewBackingStore(
Ptr, ScriptStructWrapper->Struct->GetStructureSize(),
[](void* Data, size_t Length, void* DeleterData)
{
// TFScriptStructWrapper存放在TypeReflectionMap中，Isolate先Dispose后，对象才跟着销毁
FScriptStructWrapper* StructInfo = static_cast<FScriptStructWrapper*>(DeleterData);
FScriptStructWrapper::Free(StructInfo->Struct, StructInfo->ExternalFinalize, Data);
},
ScriptStructWrapper);
auto MemoryHolder = v8::ArrayBuffer::New(MainIsolate, std::move(Backing));
__USE(JSObject->Set(MainIsolate->GetCurrentContext(), 0, MemoryHolder));
return; // early return
#endif
}
#endif
auto CacheNodePtr = StructCache.Find(Ptr);
if (CacheNodePtr)
{
CacheNodePtr = CacheNodePtr->Add(ScriptStructWrapper->Struct.Get());
}
else
{
CacheNodePtr = &StructCache.Emplace(Ptr, FObjectCacheNode(ScriptStructWrapper->Struct.Get()));
}
CacheNodePtr->Value.Reset(MainIsolate, JSObject);
CacheNodePtr->UserData = ScriptStructWrapper;
CacheNodePtr->Value.SetWeak<FScriptStructWrapper>(
ScriptStructWrapper, FScriptStructWrapper::OnGarbageCollectedWithFree, v8::WeakCallbackType::kInternalFields);
}
else
{
auto CacheNodePtr = StructCache.Find(Ptr);
if (CacheNodePtr)
{
CacheNodePtr = CacheNodePtr->Add(ScriptStructWrapper->Struct.Get());
}
else
{
CacheNodePtr = &StructCache.Emplace(Ptr, FObjectCacheNode(ScriptStructWrapper->Struct.Get()));
}
CacheNodePtr->Value.Reset(MainIsolate, JSObject);
CacheNodePtr->Value.SetWeak<FScriptStructWrapper>(
ScriptStructWrapper, FScriptStructWrapper::OnGarbageCollected, v8::WeakCallbackType::kInternalFields);
}
}
void FJsEnvImpl::BindCppObject(
v8::Isolate* InIsolate, JSClassDefinition* ClassDefinition, void* Ptr, v8::Local<v8::Object> JSObject, bool PassByPointer)
{
CppObjectMapper.BindCppObject(InIsolate, ClassDefinition, Ptr, JSObject, PassByPointer);
}
void* FJsEnvImpl::GetPrivateData(v8::Local<v8::Context> Context, v8::Local<v8::Object> JSObject)
{
return CppObjectMapper.GetPrivateData(Context, JSObject);
}
void FJsEnvImpl::SetPrivateData(v8::Local<v8::Context> Context, v8::Local<v8::Object> JSObject, void* Ptr)
{
CppObjectMapper.SetPrivateData(Context, JSObject, Ptr);
}
v8::MaybeLocal<v8::Function> FJsEnvImpl::LoadTypeById(v8::Local<v8::Context> Context, const void* TypeId)
{
return CppObjectMapper.LoadTypeById(Context, TypeId);
}
void FJsEnvImpl::UnBindStruct(FScriptStructWrapper* ScriptStructWrapper, void* Ptr)
{
auto CacheNodePtr = StructCache.Find(Ptr);
if (CacheNodePtr)
{
(void) (CacheNodePtr->Remove(ScriptStructWrapper->Struct.Get(), true));
if (!CacheNodePtr->TypeId) // last one
{
StructCache.Remove(Ptr);
}
}
}
void FJsEnvImpl::UnBindCppObject(v8::Isolate* Isolate, JSClassDefinition* ClassDefinition, void* Ptr)
{
CppObjectMapper.UnBindCppObject(Isolate, ClassDefinition, Ptr);
}
void FJsEnvImpl::BindContainer(void* Ptr, v8::Local<v8::Object> JSObject, void (*Callback)(const v8::WeakCallbackInfo<void>& data),
bool PassByPointer, ContainerType Type)
{
DataTransfer::SetPointer(MainIsolate, JSObject, Ptr, 0);
ContainerCacheItem& Val =
ContainerCache.Add(Ptr, {v8::UniquePersistent<v8::Value>(MainIsolate, JSObject), !PassByPointer, Type});
Val.Container.SetWeak<void>(nullptr, Callback, v8::WeakCallbackType::kInternalFields);
}
void FJsEnvImpl::UnBindContainer(void* Ptr)
{
ContainerCache.Remove(Ptr);
}
std::shared_ptr<FStructWrapper> FJsEnvImpl::GetStructWrapper(UStruct* InStruct, bool& IsReuseTemplate)
{
const auto FullName = InStruct->GetFullName();
auto TypeReflectionPtr = TypeReflectionMap.Find(FullName);
if (!TypeReflectionPtr)
{
auto Ret = std::make_shared<FStructWrapper>(InStruct);
TypeReflectionMap.Add(FullName, Ret);
// UE_LOG(LogTemp, Warning, TEXT("FJsEnvImpl::GetStructWrapper new %s // %s"), *InStruct->GetName(), *FullName);
return Ret;
}
else
{
#if PUERTS_REUSE_STRUCTWRAPPER_FUNCTIONTEMPLATE
IsReuseTemplate = true;
#endif
// UE_LOG(LogTemp, Warning, TEXT("FJsEnvImpl::GetStructWrapper existed %s // %s"), *InStruct->GetName(), *FullName);
(*TypeReflectionPtr)->Init(InStruct, IsReuseTemplate);
return (*TypeReflectionPtr);
}
}
FJsEnvImpl::FTemplateInfo* FJsEnvImpl::GetTemplateInfoOfType(UStruct* InStruct, bool& Existed)
{
auto Isolate = MainIsolate;
auto TemplateInfoPtr = TypeToTemplateInfoMap.Find(InStruct);
if (!TemplateInfoPtr)
{
if (!ExtensionMethodsMapInited)
{
InitExtensionMethodsMap();
}
v8::Local<v8::FunctionTemplate> Template;
bool IsReuseTemplate = false;
auto StructWrapper = GetStructWrapper(InStruct, IsReuseTemplate);
auto ExtensionMethodsIter = ExtensionMethodsMap.find(InStruct);
if (ExtensionMethodsIter != ExtensionMethodsMap.end())
{
StructWrapper->AddExtensionMethods(ExtensionMethodsIter->second);
ExtensionMethodsMap.erase(ExtensionMethodsIter);
}
if (auto ScriptStruct = Cast<UScriptStruct>(InStruct))
{
// Logger->Warn(FString::Printf(TEXT("UScriptStruct: %s"), *InStruct->GetName()));
Template = StructWrapper->ToFunctionTemplate(Isolate, FScriptStructWrapper::New);
if (!IsReuseTemplate)
{
#if WITH_EDITOR
Template->SetClassName(
v8::String::NewFromUtf8(Isolate, TCHAR_TO_UTF8(*InStruct->GetPathName()), v8::NewStringType::kNormal)
.ToLocalChecked());
#elif !defined(UE_SHIPPING)
Template->SetClassName(
v8::String::NewFromUtf8(Isolate, TCHAR_TO_UTF8(*InStruct->GetName()), v8::NewStringType::kNormal)
.ToLocalChecked());
#endif
}
if (!ScriptStruct->IsNative()) //非原生的结构体，可能在实例没有的时候会释放
{
SysObjectRetainer.Retain(ScriptStruct);
}
auto SuperStruct = ScriptStruct->GetSuperStruct();
if (SuperStruct)
{
bool Dummy;
if (IsReuseTemplate)
__USE(GetTemplateInfoOfType(SuperStruct, Dummy));
else
Template->Inherit(GetTemplateInfoOfType(SuperStruct, Dummy)->Template.Get(Isolate));
}
}
else
{
auto Class = Cast<UClass>(InStruct);
check(Class);
Template = StructWrapper->ToFunctionTemplate(Isolate, FClassWrapper::New);
if (!IsReuseTemplate)
{
#if WITH_EDITOR
Template->SetClassName(
v8::String::NewFromUtf8(Isolate, TCHAR_TO_UTF8(*InStruct->GetPathName()), v8::NewStringType::kNormal)
.ToLocalChecked());
#elif !defined(UE_SHIPPING)
Template->SetClassName(
v8::String::NewFromUtf8(Isolate, TCHAR_TO_UTF8(*InStruct->GetName()), v8::NewStringType::kNormal)
.ToLocalChecked());
#endif
}
#if PUERTS_KEEP_UOBJECT_REFERENCE
StructWrapper->IsNativeTakeJsRef = StructWrapper->IsTypeScriptGeneratedClass = IsTypeScriptGeneratedClass(Class);
#endif
auto SuperClass = Class->GetSuperClass();
if (SuperClass)
{
bool Dummy;
auto SuperTemplateInfo = GetTemplateInfoOfType(SuperClass, Dummy);
if (!IsReuseTemplate)
{
Template->Inherit(SuperTemplateInfo->Template.Get(Isolate));
}
if (SuperTemplateInfo->StructWrapper->IsNativeTakeJsRef)
{
StructWrapper->IsNativeTakeJsRef = true;
}
}
}
Existed = false;
return &TypeToTemplateInfoMap.Add(InStruct, {v8::UniquePersistent<v8::FunctionTemplate>(Isolate, Template), StructWrapper});
}
else
{
Existed = true;
return TemplateInfoPtr;
}
}
v8::Local<v8::Function> FJsEnvImpl::GetJsClass(UStruct* InStruct, v8::Local<v8::Context> Context)
{
bool Existed;
auto Ret = GetTemplateInfoOfType(InStruct, Existed)->Template.Get(MainIsolate)->GetFunction(Context).ToLocalChecked();
if (UNLIKELY(!Existed)) // first create
{
auto Class = Cast<UClass>(InStruct);
#if !defined(ENGINE_INDEPENDENT_JSENV)
if (Class && !Class->IsNative() && !InStruct->IsA<UTypeScriptGeneratedClass>())
{
auto SuperClass = Cast<UTypeScriptGeneratedClass>(Class->GetSuperClass());
if (SuperClass)
{
MakeSureInject(SuperClass, false, false);
v8::Local<v8::Value> VProto;
if (Ret->Get(Context, FV8Utils::ToV8String(MainIsolate, "prototype")).ToLocal(&VProto) && VProto->IsObject())
{
v8::Local<v8::Object> Proto = VProto.As<v8::Object>();
__USE(Proto->SetPrototype(Context, BindInfoMap[SuperClass].Prototype.Get(MainIsolate)));
}
}
}
#endif
}
return Ret;
}
bool FJsEnvImpl::IsInstanceOf(UStruct* Struct, v8::Local<v8::Object> JsObject)
{
//这里如果外面传一个非uobject或者ustructsrcipt的object,可能会有问题
if (Cast<UScriptStruct>(Struct))
{
UScriptStruct* ObjectStruct = (UScriptStruct*) FV8Utils::GetPointer(JsObject, 1);
return ObjectStruct && ObjectStruct->IsChildOf(Struct);
}
else
{
UObject* Object = FV8Utils::GetUObject(JsObject);
if (!Object || Object == RELEASED_UOBJECT)
{
return false;
}
return Object->GetClass()->IsChildOf(Struct);
}
}
bool FJsEnvImpl::IsInstanceOfCppObject(v8::Isolate* Isolate, const void* TypeId, v8::Local<v8::Object> JsObject)
{
return CppObjectMapper.IsInstanceOfCppObject(Isolate, TypeId, JsObject);
}
std::weak_ptr<int> FJsEnvImpl::GetJsEnvLifeCycleTracker()
{
return CppObjectMapper.GetJsEnvLifeCycleTracker();
}
v8::Local<v8::Value> FJsEnvImpl::AddSoftObjectPtr(
v8::Isolate* Isolate, v8::Local<v8::Context> Context, FSoftObjectPtr* SoftObjectPtr, UClass* Class, bool IsSoftClass)
{
const auto JSObject = SoftObjectPtrTemplate.Get(Isolate)->InstanceTemplate()->NewInstance(Context).ToLocalChecked();
DataTransfer::SetPointer(Isolate, JSObject, SoftObjectPtr, 0);
DataTransfer::SetPointer(Isolate, JSObject, Class, IsSoftClass ? 2 : 1);
DataTransfer::SetPointer(Isolate, JSObject, nullptr, IsSoftClass ? 1 : 2);
v8::Global<v8::Object>* GlobalPtr = new v8::Global<v8::Object>(Isolate, JSObject);
GlobalPtr->SetWeak<v8::Global<v8::Object>>(
GlobalPtr,
[](const v8::WeakCallbackInfo<v8::Global<v8::Object>>& Data)
{
void* Ptr = DataTransfer::MakeAddressWithHighPartOfTwo(Data.GetInternalField(0), Data.GetInternalField(1));
delete static_cast<FSoftObjectPtr*>(Ptr);
delete Data.GetParameter();
},
v8::WeakCallbackType::kInternalFields);
return JSObject;
}
v8::Local<v8::Value> FJsEnvImpl::UETypeToJsClass(v8::Isolate* Isolate, v8::Local<v8::Context> Context, UField* Type)
{
if (const auto Struct = Cast<UStruct>(Type))
{
return GetJsClass(Struct, Context);
}
if (const auto Enum = Cast<UEnum>(Type))
{
auto Result = v8::Object::New(Isolate);
for (int i = 0; i < Enum->NumEnums(); ++i)
{
#if !defined(ENGINE_INDEPENDENT_JSENV)
auto Name = Enum->IsA<UUserDefinedEnum>() ?
#if ENGINE_MINOR_VERSION >= 23 || ENGINE_MAJOR_VERSION > 4
Enum->GetAuthoredNameStringByIndex(i)
#else
Enum->GetDisplayNameTextByIndex(i).ToString()
#endif
: Enum->GetNameStringByIndex(i);
#else
auto Name = Enum->GetNameStringByIndex(i);
#endif
auto Value = Enum->GetValueByIndex(i);
__USE(Result->Set(Context, FV8Utils::ToV8String(Isolate, Name), v8::Number::New(Isolate, Value)));
__USE(Result->Set(Context, v8::Number::New(Isolate, Value), FV8Utils::ToV8String(Isolate, Name)));
}
__USE(Result->Set(
Context, FV8Utils::ToV8String(Isolate, "__puerts_ufield"), FindOrAdd(Isolate, Context, Enum->GetClass(), Enum)));
#if !defined(ENGINE_INDEPENDENT_JSENV)
if (Enum == StaticEnum<EObjectTypeQuery>())
{
UCollisionProfile* CollisionProfile = UCollisionProfile::Get();
int32 ContainerIndex = 0;
while (true)
{
FName ChannelName = CollisionProfile->ReturnChannelNameFromContainerIndex(ContainerIndex);
if (ChannelName == NAME_None)
{
break;
}
auto ObjectType = CollisionProfile->ConvertToObjectType((ECollisionChannel) ContainerIndex);
if (ObjectType != EObjectTypeQuery::ObjectTypeQuery_MAX)
{
__USE(Result->Set(Context, FV8Utils::ToV8String(Isolate, ChannelName), v8::Number::New(Isolate, ObjectType)));
__USE(Result->Set(Context, v8::Number::New(Isolate, ObjectType), FV8Utils::ToV8String(Isolate, ChannelName)));
}
ContainerIndex++;
}
}
else if (Enum == StaticEnum<ETraceTypeQuery>())
{
UCollisionProfile* CollisionProfile = UCollisionProfile::Get();
int32 ContainerIndex = 0;
while (true)
{
FName ChannelName = CollisionProfile->ReturnChannelNameFromContainerIndex(ContainerIndex);
if (ChannelName == NAME_None)
{
break;
}
auto TraceType = CollisionProfile->ConvertToTraceType((ECollisionChannel) ContainerIndex);
if (TraceType != ETraceTypeQuery::TraceTypeQuery_MAX)
{
__USE(Result->Set(Context, FV8Utils::ToV8String(Isolate, ChannelName), v8::Number::New(Isolate, TraceType)));
__USE(Result->Set(Context, v8::Number::New(Isolate, TraceType), FV8Utils::ToV8String(Isolate, ChannelName)));
}
ContainerIndex++;
}
}
#endif
return Result;
}
return v8::Undefined(Isolate);
}
void FJsEnvImpl::LoadUEType(const v8::FunctionCallbackInfo<v8::Value>& Info)
{
v8::Isolate* Isolate = Info.GetIsolate();
v8::Isolate::Scope IsolateScope(Isolate);
v8::HandleScope HandleScope(Isolate);
v8::Local<v8::Context> Context = Isolate->GetCurrentContext();
v8::Context::Scope ContextScope(Context);
CHECK_V8_ARGS(EArgString);
const FString TypeName = FV8Utils::ToFString(Isolate, Info[0]);
UField* Type = FindAnyType<UClass>(TypeName);
if (!Type)
{
Type = FindAnyType<UScriptStruct>(TypeName);
}
if (!Type)
{
Type = FindAnyType<UEnum>(TypeName);
}
if (!Type)
{
Type = LoadObject<UClass>(nullptr, *TypeName);
}
if (!Type)
{
Type = LoadObject<UScriptStruct>(nullptr, *TypeName);
}
if (!Type)
{
Type = LoadObject<UEnum>(nullptr, *TypeName);
}
if (Type && !Type->IsNative())
{
FV8Utils::ThrowException(Isolate,
FString::Printf(TEXT("%s is blueprint type, load it using UE.Class.Load('path/to/your/blueprint/file')."), *TypeName));
return;
}
auto Result = UETypeToJsClass(Isolate, Context, Type);
if (Result->IsUndefined())
{
FV8Utils::ThrowException(Isolate, FString::Printf(TEXT("can not find type:%s"), *TypeName));
}
else
{
Info.GetReturnValue().Set(Result);
}
}
void FJsEnvImpl::LoadCppType(const v8::FunctionCallbackInfo<v8::Value>& Info)
{
CppObjectMapper.LoadCppType(Info);
}
void FJsEnvImpl::UEClassToJSClass(const v8::FunctionCallbackInfo<v8::Value>& Info)
{
v8::Isolate* Isolate = Info.GetIsolate();
v8::Isolate::Scope IsolateScope(Isolate);
v8::HandleScope HandleScope(Isolate);
v8::Local<v8::Context> Context = Isolate->GetCurrentContext();
v8::Context::Scope ContextScope(Context);
CHECK_V8_ARGS(EArgObject);
UField* Type = nullptr;
if (UObject* Object = FV8Utils::GetUObject(Context, Info[0]))
{
if (FV8Utils::IsReleasedPtr(Object))
{
FV8Utils::ThrowException(Isolate, "passing a invalid object");
return;
}
Type = Cast<UField>(Object);
}
if (Type)
{
Info.GetReturnValue().Set(UETypeToJsClass(Isolate, Context, Type));
}
else
{
FV8Utils::ThrowException(Isolate, FString::Printf(TEXT("argument #0 expect a UField")));
}
}
void FJsEnvImpl::SetJsTakeRefInTs(const v8::FunctionCallbackInfo<v8::Value>& Info)
{
v8::Isolate* Isolate = Info.GetIsolate();
v8::Local<v8::Context> Context = Isolate->GetCurrentContext();
CHECK_V8_ARGS(EArgObject);
UObject* Object = FV8Utils::GetUObject(Context, Info[0]);
bool Existed;
auto TemplateInfoPtr = GetTemplateInfoOfType(Object->GetClass(), Existed);
SetJsTakeRef(Object, static_cast<FClassWrapper*>(TemplateInfoPtr->StructWrapper.get()));
}
bool FJsEnvImpl::GetContainerTypeProperty(v8::Local<v8::Context> Context, v8::Local<v8::Value> Value, PropertyMacro** PropertyPtr)
{
if (Value->IsInt32())
{
int Type = Value->Int32Value(Context).ToChecked();
if (Type >= MaxBuiltinType)
{
*PropertyPtr = nullptr;
return false;
}
*PropertyPtr = ContainerMeta.GetBuiltinProperty((BuiltinType) Type);
return true;
}
else if (auto Field = Cast<UField>(FV8Utils::GetUObject(Context, Value)))
{
*PropertyPtr = ContainerMeta.GetObjectProperty(Field);
return *PropertyPtr != nullptr;
}
else
{
*PropertyPtr = nullptr;
return false;
}
}
void FJsEnvImpl::NewContainer(const v8::FunctionCallbackInfo<v8::Value>& Info)
{
v8::Isolate* Isolate = Info.GetIsolate();
v8::Isolate::Scope IsolateScope(Isolate);
v8::HandleScope HandleScope(Isolate);
v8::Local<v8::Context> Context = Isolate->GetCurrentContext();
v8::Context::Scope ContextScope(Context);
CHECK_V8_ARGS(EArgInt32);
int ContainerType = Info[0]->Int32Value(Context).ToChecked();
PropertyMacro* Property1 = nullptr;
PropertyMacro* Property2 = nullptr;
FScriptArray* ScriptArray = nullptr;
FScriptSet* ScriptSet = nullptr;
FScriptMap* ScriptMap = nullptr;
if (!GetContainerTypeProperty(Context, Info[1], &Property1))
{
FV8Utils::ThrowException(Isolate, FString::Printf(TEXT("can not get first type for %d"), ContainerType));
return;
}
switch (ContainerType)
{
case 0: // Array
ScriptArray = reinterpret_cast<FScriptArray*>(new FScriptArrayEx(Property1));
// Logger->Info(FString::Printf(TEXT("Array %s"), *Property1->GetClass()->GetName()));
Info.GetReturnValue().Set(FindOrAddContainer(Isolate, Context, Property1, ScriptArray, false));
break;
case 1: // Set
ScriptSet = reinterpret_cast<FScriptSet*>(new FScriptSetEx(Property1));
// Logger->Info(FString::Printf(TEXT("Set %s"), *Property1->GetClass()->GetName()));
Info.GetReturnValue().Set(FindOrAddContainer(Isolate, Context, Property1, ScriptSet, false));
break;
case 2: // Map
if (!GetContainerTypeProperty(Context, Info[2], &Property2))
{
FV8Utils::ThrowException(Isolate, FString::Printf(TEXT("can not get second type for %d"), ContainerType));
return;
}
// Logger->Info(FString::Printf(TEXT("Map %s %s"), *Property1->GetClass()->GetName(),
// *Property2->GetClass()->GetName()));
ScriptMap = reinterpret_cast<FScriptMap*>(new FScriptMapEx(Property1, Property2));
Info.GetReturnValue().Set(FindOrAddContainer(Isolate, Context, Property1, Property2, ScriptMap, false));
break;
default:
FV8Utils::ThrowException(Isolate, FString::Printf(TEXT("invalid container type %d"), ContainerType));
}
}
void FJsEnvImpl::Start(const FString& ModuleNameOrScript, const TArray<TPair<FString, UObject*>>& Arguments)
{
#ifdef SINGLE_THREAD_VERIFY
ensureMsgf(BoundThreadId == FPlatformTLS::GetCurrentThreadId(), TEXT("Access by illegal thread!"));
#endif
if (Started)
{
Logger->Error("Started yet!");
return;
}
auto Isolate = MainIsolate;
#ifdef THREAD_SAFE
v8::Locker Locker(Isolate);
#endif
v8::Isolate::Scope IsolateScope(Isolate);
v8::HandleScope HandleScope(Isolate);
auto Context = v8::Local<v8::Context>::New(Isolate, DefaultContext);
v8::Context::Scope ContextScope(Context);
auto MaybeTGameTGJS = Context->Global()->Get(Context, FV8Utils::ToV8String(Isolate, "puerts"));
if (MaybeTGameTGJS.IsEmpty() || !MaybeTGameTGJS.ToLocalChecked()->IsObject())
{
Logger->Error("global.puerts not found!");
return;
}
auto TGJS = MaybeTGameTGJS.ToLocalChecked()->ToObject(Context).ToLocalChecked();
auto MaybeArgv = TGJS->Get(Context, FV8Utils::ToV8String(Isolate, "argv"));
if (MaybeArgv.IsEmpty() || !MaybeArgv.ToLocalChecked()->IsObject())
{
Logger->Error("global.puerts.argv not found!");
return;
}
auto Argv = MaybeArgv.ToLocalChecked()->ToObject(Context).ToLocalChecked();
auto MaybeArgvAdd = Argv->Get(Context, FV8Utils::ToV8String(Isolate, "add"));
if (MaybeArgvAdd.IsEmpty() || !MaybeArgvAdd.ToLocalChecked()->IsFunction())
{
Logger->Error("global.puerts.argv.add not found!");
return;
}
auto ArgvAdd = MaybeArgvAdd.ToLocalChecked().As<v8::Function>();
for (int i = 0; i < Arguments.Num(); i++)
{
auto Object = Arguments[i].Value;
v8::Local<v8::Value> Args[2] = {
FV8Utils::ToV8String(Isolate, Arguments[i].Key), FindOrAdd(Isolate, Context, Object->GetClass(), Object)};
(void) (ArgvAdd->Call(Context, Argv, 2, Args));
}
v8::TryCatch TryCatch(Isolate);
v8::Local<v8::Value> Args[] = {FV8Utils::ToV8String(Isolate, ModuleNameOrScript)};
__USE(Require.Get(Isolate)->Call(Context, v8::Undefined(Isolate), 1, Args));
if (TryCatch.HasCaught())
{
Logger->Error(FV8Utils::TryCatchToString(Isolate, &TryCatch));
}
Started = true;
}
bool FJsEnvImpl::LoadFile(const FString& RequiringDir, const FString& ModuleName, FString& OutPath, FString& OutDebugPath,
TArray<uint8>& Data, FString& ErrInfo)
{
if (ModuleLoader->Search(RequiringDir, ModuleName, OutPath, OutDebugPath))
{
if (!ModuleLoader->Load(OutPath, Data))
{
ErrInfo = FString::Printf(TEXT("can not load [%s]"), *ModuleName);
return false;
}
}
else
{
ErrInfo = FString::Printf(TEXT("can not find [%s]"), *ModuleName);
return false;
}
return true;
}
#ifndef WITH_QUICKJS
std::unordered_multimap<int, FJsEnvImpl::FModuleInfo*>::iterator FJsEnvImpl::FindModuleInfo(v8::Local<v8::Module> Module)
{
auto Range = HashToModuleInfo.equal_range(Module->GetIdentityHash());
for (auto It = Range.first; It != Range.second; ++It)
{
if (It->second->Module == Module)
{
return It;
}
}
return HashToModuleInfo.end();
}
v8::MaybeLocal<v8::Module> FJsEnvImpl::ResolveModuleCallback(v8::Local<v8::Context> Context, v8::Local<v8::String> Specifier,
#if V8_MAJOR_VERSION >= 9
v8::Local<v8::FixedArray> ImportAttributes, // not implement yet
#endif
v8::Local<v8::Module> Referrer)
{
auto Self = static_cast<FJsEnvImpl*>(FV8Utils::IsolateData<IObjectMapper>(Context->GetIsolate()));
const auto ItModuleInfo = Self->FindModuleInfo(Referrer);
check(ItModuleInfo != Self->HashToModuleInfo.end());
const auto RefModuleName = FV8Utils::ToFString(Context->GetIsolate(), Specifier);
auto ItRefModule = ItModuleInfo->second->ResolveCache.Find(RefModuleName);
check(ItRefModule);
return (*ItRefModule).Get(Context->GetIsolate());
}
v8::MaybeLocal<v8::Module> FJsEnvImpl::FetchCJSModuleAsESModule(v8::Local<v8::Context> Context, const FString& ModuleName)
{
#if V8_MAJOR_VERSION < 8
FV8Utils::ThrowException(
MainIsolate, FString::Printf(TEXT("V8_MAJOR_VERSION < 8 not support fetch CJS module [%s] from ESM"), *ModuleName));
return v8::MaybeLocal<v8::Module>();
#else
const auto Isolate = Context->GetIsolate();
Logger->Info(FString::Printf(TEXT("ESM Fetch CJS Module: %s"), *ModuleName));
v8::Local<v8::Value> Args[] = {FV8Utils::ToV8String(Isolate, ModuleName)};
auto MaybeRet = Require.Get(Isolate)->Call(Context, v8::Undefined(Isolate), 1, Args);
if (MaybeRet.IsEmpty())
{
return v8::MaybeLocal<v8::Module>();
}
auto CJSValue = MaybeRet.ToLocalChecked();
std::vector<v8::Local<v8::String>> ExportNames = {
v8::String::NewFromUtf8(Isolate, "default", v8::NewStringType::kNormal).ToLocalChecked()};
if (CJSValue->IsObject())
{
auto JsObject = CJSValue->ToObject(Context).ToLocalChecked();
auto Keys = JsObject->GetOwnPropertyNames(Context).ToLocalChecked();
for (decltype(Keys->Length()) i = 0; i < Keys->Length(); ++i)
{
v8::Local<v8::Value> Key;
if (Keys->Get(Context, i).ToLocal(&Key))
{
// UE_LOG(LogTemp, Warning, TEXT("---'%s' '%s'"), *ModuleName, *FV8Utils::ToFString(Isolate, Key));
ExportNames.push_back(Key->ToString(Context).ToLocalChecked());
}
}
}
v8::Local<v8::Module> SyntheticModule =
#if defined(V8_HAS_WRAP_API_WITHOUT_STL)
v8::Module_CreateSyntheticModule_Without_Stl(Isolate, FV8Utils::ToV8String(Isolate, ModuleName), ExportNames.data(),
ExportNames.size(),
#else
v8::Module::CreateSyntheticModule(Isolate, FV8Utils::ToV8String(Isolate, ModuleName), ExportNames,
#endif
[](v8::Local<v8::Context> ContextInner, v8::Local<v8::Module> Module) -> v8::MaybeLocal<v8::Value>
{
const auto IsolateInner = ContextInner->GetIsolate();
auto Self = static_cast<FJsEnvImpl*>(FV8Utils::IsolateData<IObjectMapper>(IsolateInner));
const auto ModuleInfoIt = Self->FindModuleInfo(Module);
check(ModuleInfoIt != Self->HashToModuleInfo.end());
auto CJSValueInner = ModuleInfoIt->second->CJSValue.Get(IsolateInner);
__USE(Module->SetSyntheticModuleExport(IsolateInner,
v8::String::NewFromUtf8(IsolateInner, "default", v8::NewStringType::kNormal).ToLocalChecked(), CJSValueInner));
if (CJSValueInner->IsObject())
{
auto JsObjectInner = CJSValueInner->ToObject(ContextInner).ToLocalChecked();
auto KeysInner = JsObjectInner->GetOwnPropertyNames(ContextInner).ToLocalChecked();
for (decltype(KeysInner->Length()) ii = 0; ii < KeysInner->Length(); ++ii)
{
v8::Local<v8::Value> KeyInner;
v8::Local<v8::Value> ValueInner;
if (KeysInner->Get(ContextInner, ii).ToLocal(&KeyInner) &&
JsObjectInner->Get(ContextInner, KeyInner).ToLocal(&ValueInner))
{
// UE_LOG(LogTemp, Warning, TEXT("-----set '%s'"), *FV8Utils::ToFString(IsolateInner, KeyInner));
__USE(Module->SetSyntheticModuleExport(
IsolateInner, KeyInner->ToString(ContextInner).ToLocalChecked(), ValueInner));
}
}
}
return v8::MaybeLocal<v8::Value>(v8::True(IsolateInner));
});
FModuleInfo* Info = new FModuleInfo;
Info->Module.Reset(Isolate, SyntheticModule);
Info->CJSValue.Reset(Isolate, CJSValue);
HashToModuleInfo.emplace(SyntheticModule->GetIdentityHash(), Info);
return SyntheticModule;
#endif
}
v8::MaybeLocal<v8::Module> FJsEnvImpl::FetchESModuleTree(v8::Local<v8::Context> Context, const FString& FileName)
{
const auto Isolate = Context->GetIsolate();
if (PathToModule.Contains(FileName))
{
return PathToModule[FileName].Get(Isolate);
}
Logger->Info(FString::Printf(TEXT("Fetch ES Module: %s"), *FileName));
TArray<uint8> Data;
if (!ModuleLoader->Load(FileName, Data))
{
FV8Utils::ThrowException(MainIsolate, FString::Printf(TEXT("can not load [%s]"), *FileName));
return v8::MaybeLocal<v8::Module>();
}
v8::Local<v8::String> Source;
v8::ScriptCompiler::CachedData* CachedCode = nullptr;
v8::ScriptCompiler::CompileOptions Options = v8::ScriptCompiler::CompileOptions::kNoCompileOptions;
#if defined(WITH_V8_BYTECODE)
if (FileName.EndsWith(TEXT(".mbc")))
{
FCodeCacheHeader* CodeCacheHeader = (FCodeCacheHeader*) Data.GetData();
if (CodeCacheHeader->FlagHash != Expect_FlagHash)
{
UE_LOG(Puerts, Warning, TEXT("FlagHash not match expect %u, but got %u"), Expect_FlagHash, CodeCacheHeader->FlagHash);
CodeCacheHeader->FlagHash = Expect_FlagHash;
}
#if V8_MAJOR_VERSION >= 11
if (CodeCacheHeader->ReadOnlySnapshotChecksum != Expect_ReadOnlySnapshotChecksum)
{
UE_LOG(Puerts, Warning, TEXT("ReadOnlySnapshotChecksum not match expect %u, but got %u"),
Expect_ReadOnlySnapshotChecksum, CodeCacheHeader->ReadOnlySnapshotChecksum);
CodeCacheHeader->ReadOnlySnapshotChecksum = Expect_ReadOnlySnapshotChecksum;
}
#endif
static constexpr uint32_t kModuleFlagMask = (1 << 31);
uint32_t Len = CodeCacheHeader->SourceHash & ~kModuleFlagMask;
v8::Local<v8::Value> Args[] = {v8::Integer::New(Isolate, Len)};
v8::Local<v8::Value> Ret;
if (!GenEmptyCode.Get(Isolate)->Call(Context, v8::Undefined(Isolate), 1, Args).ToLocal(&Ret) || !Ret->IsString())
{
FV8Utils::ThrowException(MainIsolate, FString::Printf(TEXT("generate code for bytecode [%s] fail!"), *FileName));
return v8::MaybeLocal<v8::Module>();
}
CachedCode = new v8::ScriptCompiler::CachedData(Data.GetData(), Data.Num()); // will delete by ~Source
Options = v8::ScriptCompiler::CompileOptions::kConsumeCodeCache;
Source = Ret.As<v8::String>();
}
else
#endif
{
FString Script;
FFileHelper::BufferToString(Script, Data.GetData(), Data.Num());
Source = FV8Utils::ToV8String(Isolate, Script);
}
#if V8_MAJOR_VERSION > 8
v8::ScriptOrigin Origin(
Isolate, FV8Utils::ToV8String(Isolate, FileName), 0, 0, false, -1, v8::Local<v8::Value>(), false, false, true);
#else
v8::ScriptOrigin Origin(FV8Utils::ToV8String(Isolate, FileName), v8::Local<v8::Integer>(), v8::Local<v8::Integer>(),
v8::Local<v8::Boolean>(), v8::Local<v8::Integer>(), v8::Local<v8::Value>(), v8::Local<v8::Boolean>(),
v8::Local<v8::Boolean>(), v8::True(Isolate));
#endif
v8::ScriptCompiler::Source ScriptSource(Source, Origin, CachedCode);
v8::Local<v8::Module> Module;
if (!v8::ScriptCompiler::CompileModule(Isolate, &ScriptSource, Options).ToLocal(&Module))
{
return v8::MaybeLocal<v8::Module>();
}
PathToModule.Add(FileName, v8::Global<v8::Module>(Isolate, Module));
FModuleInfo* Info = new FModuleInfo;
Info->Module.Reset(Isolate, Module);
HashToModuleInfo.emplace(Module->GetIdentityHash(), Info);
auto DirName = FPaths::GetPath(FileName);
#if V8_MAJOR_VERSION >= 9
v8::Local<v8::FixedArray> module_requests = Module->GetModuleRequests();
for (int i = 0, Length = module_requests->Length(); i < Length; ++i)
{
v8::Local<v8::ModuleRequest> module_request = module_requests->Get(Context, i).As<v8::ModuleRequest>();
auto RefModuleName = FV8Utils::ToFString(Isolate, module_request->GetSpecifier());
#else
for (int i = 0, Length = Module->GetModuleRequestsLength(); i < Length; ++i)
{
auto RefModuleName = FV8Utils::ToFString(Isolate, Module->GetModuleRequest(i));
#endif
FString OutPath;
FString OutDebugPath;
if (ModuleLoader->Search(DirName, RefModuleName, OutPath, OutDebugPath))
{
if (OutPath.EndsWith(TEXT("package.json")))
{
TArray<uint8> PackageData;
if (ModuleLoader->Load(OutPath, PackageData))
{
FString PackageScript;
FFileHelper::BufferToString(PackageScript, PackageData.GetData(), PackageData.Num());
v8::Local<v8::Value> Args[] = {FV8Utils::ToV8String(Isolate, PackageScript)};
auto MaybeRet = GetESMMain.Get(Isolate)->Call(Context, v8::Undefined(Isolate), 1, Args);
v8::Local<v8::Value> ESMMainValue;
if (MaybeRet.ToLocal(&ESMMainValue) && ESMMainValue->IsString())
{
FString ESMMain = FV8Utils::ToFString(Isolate, ESMMainValue);
FString ESMMainOutPath;
FString ESMMainOutDebugPath;
if (ModuleLoader->Search(FPaths::GetPath(OutPath), ESMMain, ESMMainOutPath, ESMMainOutDebugPath))
{
OutPath = ESMMainOutPath;
}
}
}
}
if (OutPath.EndsWith(TEXT(".mjs")) || OutPath.EndsWith(TEXT(".js")))
{
auto RefModule = FetchESModuleTree(Context, OutPath);
if (RefModule.IsEmpty())
{
return v8::MaybeLocal<v8::Module>();
}
Info->ResolveCache.Add(RefModuleName, v8::Global<v8::Module>(Isolate, RefModule.ToLocalChecked()));
continue;
}
}
auto RefModule = FetchCJSModuleAsESModule(Context, OutPath.EndsWith(TEXT(".cjs")) ? OutPath : RefModuleName);
if (RefModule.IsEmpty())
{
FV8Utils::ThrowException(
MainIsolate, FString::Printf(TEXT("can not resolve [%s], import by [%s]"), *RefModuleName, *FileName));
return v8::MaybeLocal<v8::Module>();
}
Info->ResolveCache.Add(RefModuleName, v8::Global<v8::Module>(Isolate, RefModule.ToLocalChecked()));
}
return Module;
}
#endif
void FJsEnvImpl::ExecuteModule(const FString& ModuleName)
{
FString OutPath;
FString DebugPath;
TArray<uint8> Data;
FString ErrInfo;
if (!LoadFile(TEXT(""), ModuleName, OutPath, DebugPath, Data, ErrInfo))
{
Logger->Error(ErrInfo);
return;
}
// #if UE_BUILD_DEBUG || UE_BUILD_DEVELOPMENT
// if (!DebugPath.IsEmpty())
// OutPath = DebugPath;
// #endif
auto Isolate = MainIsolate;
v8::Isolate::Scope IsolateScope(Isolate);
v8::HandleScope HandleScope(Isolate);
auto Context = v8::Local<v8::Context>::New(Isolate, DefaultContext);
v8::Context::Scope ContextScope(Context);
#ifndef WITH_QUICKJS
if (OutPath.EndsWith(".mjs"))
{
v8::TryCatch TryCatch(Isolate);
v8::Local<v8::Module> RootModule;
if (!FetchESModuleTree(Context, OutPath).ToLocal(&RootModule))
{
check(TryCatch.HasCaught());
Logger->Error(FV8Utils::TryCatchToString(Isolate, &TryCatch));
return;
}
if (RootModule->InstantiateModule(Context, ResolveModuleCallback).FromMaybe(false))
{
__USE(RootModule->Evaluate(Context));
}
if (TryCatch.HasCaught())
{
Logger->Error(FV8Utils::TryCatchToString(Isolate, &TryCatch));
return;
}
}
else
#endif
{
v8::Local<v8::String> Source = FV8Utils::ToV8StringFromFileContent(Isolate, Data);
#if PLATFORM_WINDOWS
// 修改URL分隔符格式，否则无法匹配Inspector协议在打断点时发送的正则表达式，导致断点失败
FString FormattedScriptUrl = DebugPath.Replace(TEXT("/"), TEXT("\\"));
#else
FString FormattedScriptUrl = DebugPath;
#endif
v8::Local<v8::String> Name = FV8Utils::ToV8String(Isolate, FormattedScriptUrl);
#if V8_MAJOR_VERSION > 8
v8::ScriptOrigin Origin(Isolate, Name);
#else
v8::ScriptOrigin Origin(Name);
#endif
v8::TryCatch TryCatch(Isolate);
auto CompiledScript = v8::Script::Compile(Context, Source, &Origin);
if (CompiledScript.IsEmpty())
{
Logger->Error(FV8Utils::TryCatchToString(Isolate, &TryCatch));
return;
}
(void) (CompiledScript.ToLocalChecked()->Run(Context));
if (TryCatch.HasCaught())
{
Logger->Error(FV8Utils::TryCatchToString(Isolate, &TryCatch));
return;
}
}
}
void FJsEnvImpl::EvalScript(const v8::FunctionCallbackInfo<v8::Value>& Info)
{
v8::Isolate* Isolate = Info.GetIsolate();
v8::Isolate::Scope IsolateScope(Isolate);
v8::HandleScope HandleScope(Isolate);
v8::Local<v8::Context> Context = Isolate->GetCurrentContext();
v8::Context::Scope ContextScope(Context);
#ifndef WITH_QUICKJS
bool IsESM = Info[2]->BooleanValue(Isolate);
if (IsESM)
{
FString FullPath = FV8Utils::ToFString(Isolate, Info[3]);
v8::Local<v8::Module> RootModule;
if (!FetchESModuleTree(Context, FullPath).ToLocal(&RootModule))
{
return;
}
if (RootModule->InstantiateModule(Context, ResolveModuleCallback).FromMaybe(false))
{
auto MaybeResult = RootModule->Evaluate(Context);
v8::Local<v8::Value> Result;
if (MaybeResult.ToLocal(&Result))
{
if (Result->IsPromise())
{
v8::Local<v8::Promise> ResultPromise(Result.As<v8::Promise>());
while (ResultPromise->State() == v8::Promise::kPending)
{
Isolate->PerformMicrotaskCheckpoint();
}
if (ResultPromise->State() == v8::Promise::kRejected)
{
ResultPromise->MarkAsHandled();
Isolate->ThrowException(ResultPromise->Result());
return;
}
}
Info.GetReturnValue().Set(RootModule->GetModuleNamespace());
}
}
return;
}
#endif
v8::String::Utf8Value UrlArg(Isolate, Info[1]);
FString ScriptUrl = UTF8_TO_TCHAR(*UrlArg);
#if PLATFORM_WINDOWS
// 修改URL分隔符格式，否则无法匹配Inspector协议在打断点时发送的正则表达式，导致断点失败
FString FormattedScriptUrl = ScriptUrl.Replace(TEXT("/"), TEXT("\\"));
#else
FString FormattedScriptUrl = ScriptUrl;
#endif
v8::Local<v8::String> Name = FV8Utils::ToV8String(Isolate, FormattedScriptUrl);
#if V8_MAJOR_VERSION > 8
v8::ScriptOrigin Origin(Isolate, Name);
#else
v8::ScriptOrigin Origin(Name);
#endif
v8::Local<v8::String> Source = Info[0]->ToString(Context).ToLocalChecked();
#if defined(WITH_V8_BYTECODE)
v8::ScriptCompiler::CachedData* CachedCode = nullptr;
uint8_t* Cache = nullptr;
v8::ScriptCompiler::CompileOptions Options = v8::ScriptCompiler::CompileOptions::kNoCompileOptions;
if (Info.Length() > 4)
{
if (Info[4]->IsArrayBuffer())
{
auto AB = Info[4].As<v8::ArrayBuffer>();
auto Length = AB->ByteLength();
Cache = new uint8_t[Length];
memcpy(Cache, DataTransfer::GetArrayBufferData(AB), Length);
CachedCode = new v8::ScriptCompiler::CachedData(Cache, Length); // will delete by ~Source
Options = v8::ScriptCompiler::CompileOptions::kConsumeCodeCache;
FCodeCacheHeader* CodeCacheHeader = (FCodeCacheHeader*) CachedCode->data;
if (CodeCacheHeader->FlagHash != Expect_FlagHash)
{
UE_LOG(
Puerts, Warning, TEXT("FlagHash not match expect %u, but got %u"), Expect_FlagHash, CodeCacheHeader->FlagHash);
CodeCacheHeader->FlagHash = Expect_FlagHash;
}
}
}
v8::ScriptCompiler::Source ScriptSource(Source, Origin, CachedCode);
auto Script = v8::ScriptCompiler::Compile(Context, &ScriptSource, Options);
if (CachedCode)
{
delete Cache;
if (CachedCode->rejected)
{
FV8Utils::ThrowException(Isolate, TEXT("invalid bytecode"));
return;
}
}
#else
auto Script = v8::Script::Compile(Context, Source, &Origin);
#endif
if (Script.IsEmpty())
{
return;
}
auto Result = Script.ToLocalChecked()->Run(Context);
if (Result.IsEmpty())
{
return;
}
Info.GetReturnValue().Set(Result.ToLocalChecked());
if (OnSourceLoadedCallback)
{
OnSourceLoadedCallback(FormattedScriptUrl);
}
}
void FJsEnvImpl::Log(const v8::FunctionCallbackInfo<v8::Value>& Info)
{
v8::Isolate* Isolate = Info.GetIsolate();
v8::Isolate::Scope IsolateScope(Isolate);
v8::HandleScope HandleScope(Isolate);
v8::Local<v8::Context> Context = Isolate->GetCurrentContext();
v8::Context::Scope ContextScope(Context);
CHECK_V8_ARGS(EArgInt32, EArgString);
auto Level = Info[0]->Int32Value(Context).ToChecked();
FString Msg = FV8Utils::ToFString(Isolate, Info[1]);
switch (Level)
{
case 1:
Logger->Info(Msg);
break;
case 2:
Logger->Warn(Msg);
break;
case 3:
Logger->Error(Msg);
break;
default:
Logger->Log(Msg);
break;
}
}
void FJsEnvImpl::SearchModule(const v8::FunctionCallbackInfo<v8::Value>& Info)
{
v8::Isolate* Isolate = Info.GetIsolate();
v8::Local<v8::Context> Context = Isolate->GetCurrentContext();
CHECK_V8_ARGS(EArgString, EArgString);
FString ModuleName = FV8Utils::ToFString(Isolate, Info[0]);
FString RequiringDir = FV8Utils::ToFString(Isolate, Info[1]);
FString OutPath;
FString OutDebugPath;
if (ModuleLoader->Search(RequiringDir, ModuleName, OutPath, OutDebugPath))
{
auto Result = v8::Array::New(Isolate);
Result->Set(Context, 0, FV8Utils::ToV8String(Isolate, OutPath)).Check();
Result->Set(Context, 1, FV8Utils::ToV8String(Isolate, OutDebugPath)).Check();
Info.GetReturnValue().Set(Result);
}
}
void FJsEnvImpl::LoadModule(const v8::FunctionCallbackInfo<v8::Value>& Info)
{
v8::Isolate* Isolate = Info.GetIsolate();
v8::Isolate::Scope IsolateScope(Isolate);
v8::HandleScope HandleScope(Isolate);
v8::Local<v8::Context> Context = Isolate->GetCurrentContext();
v8::Context::Scope ContextScope(Context);
CHECK_V8_ARGS(EArgString);
FString Path = FV8Utils::ToFString(Isolate, Info[0]);
TArray<uint8> Data;
if (!ModuleLoader->Load(Path, Data))
{
FV8Utils::ThrowException(Isolate, "can not load module");
return;
}
#if defined(WITH_V8_BYTECODE)
if (Path.EndsWith(TEXT(".cbc")) || Path.EndsWith(TEXT(".mbc")))
{
v8::Local<v8::ArrayBuffer> Ab = v8::ArrayBuffer::New(Info.GetIsolate(), Data.Num());
void* Buff = DataTransfer::GetArrayBufferData(Ab);
::memcpy(Buff, Data.GetData(), Data.Num());
Info.GetReturnValue().Set(Ab);
}
else
#endif
{
Info.GetReturnValue().Set(FV8Utils::ToV8StringFromFileContent(Isolate, Data));
}
}
void FJsEnvImpl::SetTimeout(const v8::FunctionCallbackInfo<v8::Value>& Info)
{
CHECK_V8_ARGS(EArgFunction, EArgNumber);
SetFTickerDelegate(Info, false);
}
void FJsEnvImpl::SetFTickerDelegate(const v8::FunctionCallbackInfo<v8::Value>& Info, bool Continue)
{
v8::Isolate* Isolate = Info.GetIsolate();
v8::Local<v8::Context> Context = Isolate->GetCurrentContext();
while (!(++TimerID)) // TimerID > 0
{
}
uint32_t DelegateHandleId = TimerID;
FTimerInfo& TimerInfo = TimerInfos.Emplace(DelegateHandleId, FTimerInfo());
TimerInfo.Callback.Reset(Isolate, v8::Local<v8::Function>::Cast(Info[0]));
float Millisecond = Info[1]->NumberValue(Context).ToChecked();
float Delay = Millisecond / 1000.f;
TimerInfo.TickerHandle =
FUETicker::GetCoreTicker().AddTicker(FTickerDelegate::CreateLambda([this, DelegateHandleId, Continue](float)
{ return this->TimerCallback(DelegateHandleId, Continue); }),
Delay);
Info.GetReturnValue().Set(DelegateHandleId);
}
bool FJsEnvImpl::TimerCallback(int DelegateHandleId, bool Continue)
{
v8::Isolate* Isolate = MainIsolate;
#ifdef SINGLE_THREAD_VERIFY
ensureMsgf(BoundThreadId == FPlatformTLS::GetCurrentThreadId(), TEXT("Access by illegal thread!"));
#endif
#ifdef THREAD_SAFE
v8::Locker Locker(MainIsolate);
#endif
v8::Isolate::Scope Isolatescope(Isolate);
v8::HandleScope HandleScope(Isolate);
v8::Local<v8::Context> Context = DefaultContext.Get(Isolate);
v8::Context::Scope ContextScope(Context);
FTimerInfo* PTimeInfo = TimerInfos.Find(DelegateHandleId);
if (!PTimeInfo)
{
Logger->Warn(FString::Printf(TEXT("Try to callback a invalid timer: %d"), DelegateHandleId));
return false;
}
auto OriginHandle = PTimeInfo->TickerHandle;
v8::Local<v8::Function> Function = TimerInfos[DelegateHandleId].Callback.Get(Isolate);
v8::TryCatch TryCatch(Isolate);
(void) (Function->Call(Context, Context->Global(), 0, nullptr));
if (TryCatch.HasCaught())
{
FString Message =
FString::Printf(TEXT("Exception in Timer Callback: %s"), *(FV8Utils::TryCatchToString(Isolate, &TryCatch)));
Logger->Error(Message);
}
auto ClearInCallback = !TimerInfos.Contains(DelegateHandleId) || (OriginHandle != TimerInfos[DelegateHandleId].TickerHandle);
if (!Continue && !ClearInCallback)
{
RemoveFTickerDelegateHandle(DelegateHandleId);
}
return Continue && !ClearInCallback;
}
void FJsEnvImpl::RemoveFTickerDelegateHandle(int DelegateHandleId)
{
if (!TimerInfos.Contains(DelegateHandleId))
{
return;
}
FUETicker::GetCoreTicker().RemoveTicker(TimerInfos[DelegateHandleId].TickerHandle);
TimerInfos.Remove(DelegateHandleId);
}
void FJsEnvImpl::ClearInterval(const v8::FunctionCallbackInfo<v8::Value>& Info)
{
v8::Isolate* Isolate = Info.GetIsolate();
v8::Local<v8::Context> Context = Isolate->GetCurrentContext();
// todo - mocha 7.0.1，当reporter为JSON，调用clearTimeout时，可能不传值，或传Null、Undefined过来。暂将其忽略
if (Info.Length() == 0)
{
Logger->Warn(TEXT("Calling ClearInterval with 0 argument."));
}
else if (Info[0]->IsNullOrUndefined())
{
// 屏蔽这条只在mocha中出现的警告
// Logger->Warn(TEXT("Calling ClearInterval with a Null or Undefined."));
}
else
{
CHECK_V8_ARGS(EArgInt32);
int HandleId = Info[0]->Int32Value(Context).ToChecked();
RemoveFTickerDelegateHandle(HandleId);
}
}
void FJsEnvImpl::SetInterval(const v8::FunctionCallbackInfo<v8::Value>& Info)
{
v8::Isolate* Isolate = Info.GetIsolate();
v8::Isolate::Scope IsolateScope(Isolate);
v8::HandleScope HandleScope(Isolate);
v8::Local<v8::Context> Context = Isolate->GetCurrentContext();
v8::Context::Scope ContextScope(Context);
CHECK_V8_ARGS(EArgFunction, EArgNumber);
SetFTickerDelegate(Info, true);
}
#if !defined(ENGINE_INDEPENDENT_JSENV)
void FJsEnvImpl::MakeUClass(const v8::FunctionCallbackInfo<v8::Value>& Info)
{
v8::Isolate* Isolate = Info.GetIsolate();
v8::Isolate::Scope Isolatescope(Isolate);
v8::HandleScope HandleScope(Isolate);
v8::Local<v8::Context> Context = Isolate->GetCurrentContext();
v8::Context::Scope ContextScope(Context);
CHECK_V8_ARGS(EArgFunction, EArgObject, EArgString, EArgObject, EArgObject);
auto Constructor = v8::Local<v8::Function>::Cast(Info[0]);
auto Prototype = Info[1]->ToObject(Context).ToLocalChecked();
auto ClassName = FV8Utils::ToFString(Isolate, Info[2]);
auto Methods = Info[3]->ToObject(Context).ToLocalChecked();
UClass* ParentUClass = nullptr;
if (UObject* Object = FV8Utils::GetUObject(Context, Info[4]))
{
if (FV8Utils::IsReleasedPtr(Object))
{
FV8Utils::ThrowException(Isolate, "passing a invalid object");
return;
}
ParentUClass = Cast<UClass>(Object);
}
if (!ParentUClass)
{
FV8Utils::ThrowException(Isolate, "#4 parameter expect a UClass object");
return;
}
FString GenClassName;
int i = 0;
while (true)
{
GenClassName = FString::Printf(TEXT("%s%d"), *ClassName, i);
if (!FindAnyType<UClass>(GenClassName))
break;
i++;
}
auto Class = UJSGeneratedClass::Create(GenClassName, ParentUClass, DynamicInvoker, Isolate, Constructor, Prototype);
TSet<FName> overrided;
for (TFieldIterator<UFunction> It(ParentUClass, EFieldIteratorFlags::IncludeSuper, EFieldIteratorFlags::ExcludeDeprecated,
EFieldIteratorFlags::IncludeInterfaces);
It; ++It)
{
UFunction* Function = *It;
auto FunctionFName = Function->GetFName();
if (!overrided.Contains(FunctionFName) && Function->HasAnyFunctionFlags(FUNC_BlueprintEvent))
{
auto MaybeValue = Methods->Get(Context, FV8Utils::ToV8String(Isolate, Function->GetName()));
if (!MaybeValue.IsEmpty() && MaybeValue.ToLocalChecked()->IsFunction())
{
// Logger->Warn(FString::Printf(TEXT("override: %s"), *Function->GetName()));
UJSGeneratedClass::Override(
Isolate, Class, Function, v8::Local<v8::Function>::Cast(MaybeValue.ToLocalChecked()), DynamicInvoker, true);
overrided.Add(FunctionFName);
}
}
}
Class->Bind();
Class->StaticLink(true);
// Make sure CDO is ready for use
(void) (Class->GetDefaultObject());
#if ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 12
// Assemble reference token stream for garbage collection/ RTGC.
if (!Class->HasAnyClassFlags(CLASS_TokenStreamAssembled))
{
Class->AssembleReferenceTokenStream();
}
#endif
if (!GeneratedClasses.Contains(Class))
{
GeneratedClasses.Add(Class);
}
SysObjectRetainer.Retain(Class);
auto Result = FindOrAdd(Isolate, Context, Class->GetClass(), Class);
Info.GetReturnValue().Set(Result);
}
void FJsEnvImpl::Mixin(const v8::FunctionCallbackInfo<v8::Value>& Info)
{
v8::Isolate* Isolate = Info.GetIsolate();
v8::Local<v8::Context> Context = Isolate->GetCurrentContext();
CHECK_V8_ARGS(EArgObject, EArgObject);
UClass* To = nullptr;
if (UObject* Object = FV8Utils::GetUObject(Context, Info[0]))
{
if (FV8Utils::IsReleasedPtr(Object))
{
FV8Utils::ThrowException(Isolate, "passing a invalid object");
return;
}
To = Cast<UClass>(Object);
}
if (!To)
{
FV8Utils::ThrowException(Isolate, "#0 parameter expect a Blueprint UClass");
return;
}
// release
if (Info[5]->IsBoolean() && Info[5]->BooleanValue(Isolate))
{
MixinClasses.Remove(To);
UJSGeneratedClass::Restore(To);
return;
}
if (MixinClasses.Contains(To))
{
FV8Utils::ThrowException(Isolate, "had mixin");
return;
}
auto MixinMethods = Info[1]->ToObject(Context).ToLocalChecked();
bool TakeJsObjectRef = false;
if (Info[2]->IsBoolean())
{
TakeJsObjectRef = Info[2]->BooleanValue(Isolate);
}
bool Inherit = false;
if (Info[3]->IsBoolean())
{
Inherit = Info[3]->BooleanValue(Isolate);
}
bool NoWarning = false;
if (Info[4]->IsBoolean())
{
NoWarning = Info[4]->BooleanValue(Isolate);
}
UClass* New = To;
if (Inherit)
{
New = NewObject<UClass>(To->GetOuter(), To->GetClass(),
MakeUniqueObjectName(To->GetOuter(), To->GetClass(), *(To->GetName() + TEXT("_MixinGen_"))));
New->PropertyLink = To->PropertyLink;
New->ClassWithin = To->ClassWithin;
New->ClassConfigName = To->ClassConfigName;
New->ClassFlags = To->ClassFlags;
New->ClassCastFlags = To->ClassCastFlags;
New->ClassConstructor = To->ClassConstructor;
New->ClassFlags = New->ClassFlags | EClassFlags::CLASS_Transient;
New->ClassFlags = New->ClassFlags & (~EClassFlags::CLASS_Intrinsic);
New->SetFlags(EObjectFlags::RF_Transient);
New->SetSuperStruct(To);
}
auto Keys = MixinMethods->GetOwnPropertyNames(Context).ToLocalChecked();
TArray<FName> ReplaceMethodNames;
for (decltype(Keys->Length()) i = 0; i < Keys->Length(); ++i)
{
auto Key = Keys->Get(Context, i).ToLocalChecked();
auto MethodName = FV8Utils::ToFName(Isolate, Key);
auto Function = To->FindFunctionByName(MethodName);
if (Function)
{
auto JsFunc = MixinMethods->Get(Context, Key).ToLocalChecked();
auto MixinedFunc = UJSGeneratedClass::Mixin(Isolate, New, Function, MixinInvoker, TakeJsObjectRef, !NoWarning);
MixinFunctionMap.Emplace(
MixinedFunc, v8::UniquePersistent<v8::Function>(Isolate, v8::Local<v8::Function>::Cast(JsFunc)));
ReplaceMethodNames.Add(MethodName);
}
}
if (Inherit)
{
New->Bind();
New->StaticLink(true);
(void) (New->GetDefaultObject());
if (auto AnimClass = Cast<UAnimBlueprintGeneratedClass>(New))
{
AnimClass->UpdateCustomPropertyListForPostConstruction();
}
else if (auto WidgetClass = Cast<UWidgetBlueprintGeneratedClass>(New))
{
WidgetClass->UpdateCustomPropertyListForPostConstruction();
}
else if (auto BPClass = Cast<UBlueprintGeneratedClass>(New))
{
BPClass->UpdateCustomPropertyListForPostConstruction();
}
#if ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 12
// 拷贝创建的Class需要手动重新创建ReferenceTokenStream
New->AssembleReferenceTokenStream(true);
#endif
}
else
{
To->ClearFunctionMapsCaches();
bool IsReuseTemplate = false;
auto StructWrapper = GetStructWrapper(To, IsReuseTemplate);
for (int i = 0; i < ReplaceMethodNames.Num(); i++)
{
StructWrapper->RefreshMethod(To->FindFunctionByName(ReplaceMethodNames[i]));
}
}
MixinClasses.Add(New);
bool Existed = false;
__USE(GetTemplateInfoOfType(New, Existed));
bool IsReuseTemplate = false;
auto StructWrapper = GetStructWrapper(New, IsReuseTemplate);
StructWrapper->IsNativeTakeJsRef = TakeJsObjectRef;
for (auto& KV : TypeToTemplateInfoMap)
{
if (New != KV.Key && KV.Key->IsChildOf(New))
{
KV.Value.StructWrapper->IsNativeTakeJsRef = TakeJsObjectRef;
}
}
Info.GetReturnValue().Set(FindOrAdd(Isolate, Context, New->GetClass(), New));
}
#endif
void FJsEnvImpl::FindModule(const v8::FunctionCallbackInfo<v8::Value>& Info)
{
v8::Isolate* Isolate = Info.GetIsolate();
v8::Isolate::Scope Isolatescope(Isolate);
v8::HandleScope HandleScope(Isolate);
v8::Local<v8::Context> Context = Isolate->GetCurrentContext();
v8::Context::Scope ContextScope(Context);
CHECK_V8_ARGS(EArgString);
std::string Name = *(v8::String::Utf8Value(Isolate, Info[0]));
auto Func = FindAddonRegisterFunc(Name);
if (Func)
{
auto Exports = v8::Object::New(Isolate);
Func(Context, Exports);
Info.GetReturnValue().Set(Exports);
}
}
void FJsEnvImpl::SetInspectorCallback(const v8::FunctionCallbackInfo<v8::Value>& Info)
{
#ifndef WITH_QUICKJS
v8::Isolate* Isolate = Info.GetIsolate();
v8::Isolate::Scope Isolatescope(Isolate);
v8::HandleScope HandleScope(Isolate);
v8::Local<v8::Context> Context = Isolate->GetCurrentContext();
v8::Context::Scope ContextScope(Context);
if (!Inspector)
return;
CHECK_V8_ARGS(EArgFunction);
if (!InspectorChannel)
{
InspectorChannel = Inspector->CreateV8InspectorChannel();
InspectorChannel->OnMessage(
[this](std::string Message)
{
// UE_LOG(LogTemp, Warning, TEXT("<-- %s"), UTF8_TO_TCHAR(Message.c_str()));
v8::Isolate::Scope IsolatescopeObject(MainIsolate);
v8::HandleScope HandleScopeObject(MainIsolate);
v8::Local<v8::Context> ContextInner = DefaultContext.Get(MainIsolate);
v8::Context::Scope ContextScopeObject(ContextInner);
auto Handler = InspectorMessageHandler.Get(MainIsolate);
v8::Local<v8::Value> Args[] = {FV8Utils::ToV8String(MainIsolate, Message.c_str())};
v8::TryCatch TryCatch(MainIsolate);
__USE(Handler->Call(ContextInner, ContextInner->Global(), 1, Args));
if (TryCatch.HasCaught())
{
Logger->Error(FString::Printf(
TEXT("inspector callback exception %s"), *FV8Utils::TryCatchToString(MainIsolate, &TryCatch)));
}
});
}
InspectorMessageHandler.Reset(Isolate, v8::Local<v8::Function>::Cast(Info[0]));
#endif // !WITH_QUICKJS
}
void FJsEnvImpl::DispatchProtocolMessage(const v8::FunctionCallbackInfo<v8::Value>& Info)
{
#ifndef WITH_QUICKJS
v8::Isolate* Isolate = Info.GetIsolate();
v8::Isolate::Scope Isolatescope(Isolate);
v8::HandleScope HandleScope(Isolate);
v8::Local<v8::Context> Context = Isolate->GetCurrentContext();
v8::Context::Scope ContextScope(Context);
CHECK_V8_ARGS(EArgString);
if (InspectorChannel)
{
FString Message = FV8Utils::ToFString(Isolate, Info[0]);
// UE_LOG(LogTemp, Warning, TEXT("--> %s"), *Message);
InspectorChannel->DispatchProtocolMessage(TCHAR_TO_UTF8(*Message));
}
#endif // !WITH_QUICKJS
}
void FJsEnvImpl::DumpStatisticsLog(const v8::FunctionCallbackInfo<v8::Value>& Info)
{
#ifndef WITH_QUICKJS
v8::HeapStatistics Statistics;
v8::Isolate* Isolate = Info.GetIsolate();
v8::Isolate::Scope IsolateScope(Isolate);
v8::HandleScope HandleScope(Isolate);
v8::Local<v8::Context> Context = Isolate->GetCurrentContext();
v8::Context::Scope ContextScope(Context);
Isolate->GetHeapStatistics(&Statistics);
FString StatisticsLog = FString::Printf(TEXT("------------------------\n"
"Dump Statistics of V8:\n"
"total_heap_size: %llu\n"
"total_heap_size_executable: %llu\n"
"total_physical_size: %llu\n"
"total_available_size: %llu\n"
"used_heap_size: %llu\n"
"heap_size_limit: %llu\n"
"malloced_memory: %llu\n"
"external_memory: %llu\n"
"peak_malloced_memory: %llu\n"
"number_of_native_contexts: %llu\n"
"number_of_detached_contexts: %llu\n"
"does_zap_garbage: %llu\n"
"------------------------\n"),
Statistics.total_heap_size(), Statistics.total_heap_size_executable(), Statistics.total_physical_size(),
Statistics.total_available_size(), Statistics.used_heap_size(), Statistics.heap_size_limit(), Statistics.malloced_memory(),
Statistics.external_memory(), Statistics.peak_malloced_memory(), Statistics.number_of_native_contexts(),
Statistics.number_of_detached_contexts(), Statistics.does_zap_garbage());
Logger->Info(StatisticsLog);
#endif // !WITH_QUICKJS
}
#if USE_WASM3
void FJsEnvImpl::Wasm_NewMemory(const v8::FunctionCallbackInfo<v8::Value>& Info)
{
v8::Isolate* Isolate = Info.GetIsolate();
v8::Isolate::Scope IsolateScope(Isolate);
v8::HandleScope HandleScope(Isolate);
v8::Local<v8::Context> Context = Isolate->GetCurrentContext();
v8::Context::Scope ContextScope(Context);
CHECK_V8_ARGS(EArgInt32, EArgInt32);
int InitPages = Info[0]->Int32Value(Context).ToChecked();
int MaxPages = Info[1]->Int32Value(Context).ToChecked();
check(InitPages >= 0 && MaxPages > 0 && MaxPages >= InitPages);
auto Runtime = std::make_shared<WasmRuntime>(PuertsWasmEnv.get(), MaxPages, InitPages);
PuertsWasmRuntimeList.Add(Runtime);
Info.GetReturnValue().Set(Runtime->GetRuntimeSeq());
}
void FJsEnvImpl::Wasm_MemoryGrowth(const v8::FunctionCallbackInfo<v8::Value>& Info)
{
v8::Isolate* Isolate = Info.GetIsolate();
v8::Isolate::Scope IsolateScope(Isolate);
v8::HandleScope HandleScope(Isolate);
v8::Local<v8::Context> Context = Isolate->GetCurrentContext();
v8::Context::Scope ContextScope(Context);
CHECK_V8_ARGS(EArgInt32, EArgInt32);
int Seq = Info[0]->Int32Value(Context).ToChecked();
int n = Info[1]->Int32Value(Context).ToChecked();
for (auto Runtime : PuertsWasmRuntimeList)
{
if (Runtime->GetRuntimeSeq() == Seq)
{
int previous = Runtime->Grow(n);
Info.GetReturnValue().Set(previous);
return;
}
}
FV8Utils::ThrowException(Isolate, "can not find associated runtime with memory");
return;
}
void FJsEnvImpl::Wasm_MemoryBuffer(const v8::FunctionCallbackInfo<v8::Value>& Info)
{
v8::Isolate* Isolate = Info.GetIsolate();
v8::Isolate::Scope IsolateScope(Isolate);
v8::HandleScope HandleScope(Isolate);
v8::Local<v8::Context> Context = Isolate->GetCurrentContext();
v8::Context::Scope ContextScope(Context);
CHECK_V8_ARGS(EArgInt32);
int Seq = Info[0]->Int32Value(Context).ToChecked();
for (auto Runtime : PuertsWasmRuntimeList)
{
if (Runtime->GetRuntimeSeq() == Seq)
{
int Length = 0;
uint8* Ptr = Runtime->GetBuffer(Length);
if (Ptr)
{
auto Buffer = DataTransfer::NewArrayBuffer(Context, Ptr, Length);
Info.GetReturnValue().Set(Buffer);
}
else
{
FV8Utils::ThrowException(Isolate, "no memory?");
}
return;
}
}
FV8Utils::ThrowException(Isolate, "can not find associated runtime with memory");
return;
}
void FJsEnvImpl::Wasm_TableGrowth(const v8::FunctionCallbackInfo<v8::Value>& Info)
{
v8::Isolate* Isolate = Info.GetIsolate();
v8::Isolate::Scope IsolateScope(Isolate);
v8::HandleScope HandleScope(Isolate);
v8::Local<v8::Context> Context = Isolate->GetCurrentContext();
v8::Context::Scope ContextScope(Context);
CHECK_V8_ARGS(EArgInt32, EArgInt32, EArgInt32);
int Seq = Info[0]->Int32Value(Context).ToChecked();
int Index = Info[1]->Int32Value(Context).ToChecked();
int N = Info[2]->Int32Value(Context).ToChecked();
for (auto Runtime : PuertsWasmRuntimeList)
{
if (Runtime->GetRuntimeSeq() == Seq)
{
if (auto ModuleInstance = Runtime->GetModuleInstance(Index))
{
Info.GetReturnValue().Set(static_cast<uint32_t>(ModuleInstance->TableGrow(N)));
}
else
{
FV8Utils::ThrowException(Isolate, "invalid Module Instance index");
}
return;
}
}
FV8Utils::ThrowException(Isolate, "can not find associated runtime with memory");
}
void FJsEnvImpl::Wasm_TableSet(const v8::FunctionCallbackInfo<v8::Value>& Info)
{
v8::Isolate* Isolate = Info.GetIsolate();
v8::Isolate::Scope IsolateScope(Isolate);
v8::HandleScope HandleScope(Isolate);
v8::Local<v8::Context> Context = Isolate->GetCurrentContext();
v8::Context::Scope ContextScope(Context);
CHECK_V8_ARGS(EArgInt32, EArgInt32, EArgInt32, EArgFunction);
int Seq = Info[0]->Int32Value(Context).ToChecked();
int Index = Info[1]->Int32Value(Context).ToChecked();
int Pos = Info[2]->Int32Value(Context).ToChecked();
auto Func = v8::Local<v8::Function>::Cast(Info[3]);
v8::Local<v8::Value> FuncData;
if (!Func->Get(Context, FV8Utils::ToV8String(Isolate, M3_FUNCTION_KEY)).ToLocal(&FuncData) || !FuncData->IsExternal())
{
FV8Utils::ThrowException(Isolate, "Argument 1 must be null or a WebAssembly function of type compatible to 'this'");
return;
}
for (auto Runtime : PuertsWasmRuntimeList)
{
if (Runtime->GetRuntimeSeq() == Seq)
{
if (auto ModuleInstance = Runtime->GetModuleInstance(Index))
{
ModuleInstance->TableSet(Pos, static_cast<IM3Function>(v8::Local<v8::External>::Cast(FuncData)->Value()));
}
else
{
FV8Utils::ThrowException(Isolate, "invalid Module Instance index");
}
return;
}
}
FV8Utils::ThrowException(Isolate, "can not find associated runtime with memory");
}
void FJsEnvImpl::Wasm_TableLen(const v8::FunctionCallbackInfo<v8::Value>& Info)
{
v8::Isolate* Isolate = Info.GetIsolate();
v8::Isolate::Scope IsolateScope(Isolate);
v8::HandleScope HandleScope(Isolate);
v8::Local<v8::Context> Context = Isolate->GetCurrentContext();
v8::Context::Scope ContextScope(Context);
CHECK_V8_ARGS(EArgInt32, EArgInt32);
int Seq = Info[0]->Int32Value(Context).ToChecked();
int Index = Info[1]->Int32Value(Context).ToChecked();
for (auto Runtime : PuertsWasmRuntimeList)
{
if (Runtime->GetRuntimeSeq() == Seq)
{
if (auto ModuleInstance = Runtime->GetModuleInstance(Index))
{
Info.GetReturnValue().Set(static_cast<uint32_t>(ModuleInstance->TableLen()));
}
else
{
FV8Utils::ThrowException(Isolate, "invalid Module Instance index");
}
return;
}
}
FV8Utils::ThrowException(Isolate, "can not find associated runtime with memory");
}
void FJsEnvImpl::Wasm_Instance(const v8::FunctionCallbackInfo<v8::Value>& Info)
{
v8::Isolate* Isolate = Info.GetIsolate();
v8::Isolate::Scope IsolateScope(Isolate);
v8::HandleScope HandleScope(Isolate);
v8::Local<v8::Context> Context = Isolate->GetCurrentContext();
v8::Context::Scope ContextScope(Context);
// typedarray or arraybuffer, importobject or undefined, exports object
if (Info.Length() != 3)
{
FV8Utils::ThrowException(Isolate, "params number dismatch");
return;
}
if (!Info[2]->IsObject())
{
FV8Utils::ThrowException(Isolate, "params at 3 must be object");
return;
}
v8::Local<v8::Object> ExportsObject = Info[2].As<v8::Object>();
v8::Local<v8::ArrayBuffer> InArrayBuffer;
if (Info[0]->IsArrayBuffer())
{
InArrayBuffer = Info[0].As<v8::ArrayBuffer>();
}
else if (Info[0]->IsTypedArray())
{
InArrayBuffer = Info[0].As<v8::TypedArray>()->Buffer();
}
void* Buffer = static_cast<char*>(DataTransfer::GetArrayBufferData(InArrayBuffer));
int BufferLength = InArrayBuffer->ByteLength();
TArray<uint8> InData;
InData.Append((uint8*) Buffer, BufferLength);
auto Runtime = NormalInstanceModule(
Isolate, Context, InData, ExportsObject, Info[1], PuertsWasmRuntimeList, PuertsWasmCachedLinkFunctionList);
if (Runtime)
{
Info.GetReturnValue().Set(Runtime->GetRuntimeSeq());
}
}
void FJsEnvImpl::Wasm_OverrideWebAssembly(const v8::FunctionCallbackInfo<v8::Value>& Info)
{
#if WASM3_OVERRIDE_WEBASSEMBLY
Info.GetReturnValue().Set(v8::True(Info.GetIsolate()));
#else
Info.GetReturnValue().Set(v8::False(Info.GetIsolate()));
#endif
}
#endif
} // namespace PUERTS_NAMESPACE
Reference in New Issue View Git Blame Copy Permalink