“初始化俯视角工程，带puerts，未编过”

2024-12-01 02:11:25 +08:00
parent 04698dd585
commit 850d76173c
1491 changed files with 271579 additions and 0 deletions
@@ -0,0 +1,281 @@
+/*
+ * Tencent is pleased to support the open source community by making Puerts available.
+ * Copyright (C) 2020 THL A29 Limited, a Tencent company.  All rights reserved.
+ * Puerts is licensed under the BSD 3-Clause License, except for the third-party components listed in the file 'LICENSE' which may
+ * be subject to their corresponding license terms. This file is subject to the terms and conditions defined in file 'LICENSE',
+ * which is part of this source code package.
+ */
+
+#pragma once
+
+#include "Binding.hpp"
+#include "pesapi.h"
+#include <iostream>
+
+namespace PUERTS_NAMESPACE
+{
+namespace internal
+{
+class AutoValueScope
+{
+public:
+    AutoValueScope(pesapi_env_ref env_holder)
+    {
+        scope = pesapi_open_scope(env_holder);
+    }
+
+    ~AutoValueScope()
+    {
+        pesapi_close_scope(scope);
+    }
+
+    pesapi_scope scope;
+};
+}    // namespace internal
+namespace pesapi_impl
+{
+static inline void REPORT_EXCEPTION(const char* MSG)
+{
+    std::cout << "call function throw: " << MSG << std::endl;
+}
+
+class Object
+{
+public:
+    Object(pesapi_env env, pesapi_value value)
+    {
+        if (!env || !value || IsNullOrUndefined(env, value))
+        {
+            env_holder = nullptr;
+            value_holder = nullptr;
+        }
+        else
+        {
+            env_holder = pesapi_create_env_ref(env);
+            value_holder = pesapi_create_value_ref(env, value, 0);
+        }
+    }
+
+    Object(const Object& InOther)
+    {
+        if (!InOther.env_holder || !InOther.value_holder)
+        {
+            env_holder = nullptr;
+            value_holder = nullptr;
+        }
+        else
+        {
+            env_holder = pesapi_duplicate_env_ref(InOther.env_holder);
+            value_holder = pesapi_duplicate_value_ref(InOther.value_holder);
+        }
+    }
+
+    ~Object()
+    {
+        if (!env_holder || !value_holder)
+            return;
+        pesapi_release_value_ref(value_holder);
+        pesapi_release_env_ref(env_holder);
+    }
+
+    template <typename T>
+    T Get(const char* key) const
+    {
+        if (!env_holder || !value_holder)
+            return {};
+        internal::AutoValueScope ValueScope(env_holder);
+        auto env = pesapi_get_env_from_ref(env_holder);
+        auto object = pesapi_get_value_from_ref(env, value_holder);
+
+        auto value = pesapi_get_property(env, object, key);
+        if (!pesapi_is_undefined(env, value))
+        {
+            return pesapi_impl::Converter<T>::toCpp(env, value);
+        }
+        return {};
+    }
+
+    template <typename T>
+    void Set(const char* key, T val) const
+    {
+        if (!env_holder || !value_holder)
+            return;
+        internal::AutoValueScope ValueScope(env_holder);
+        auto env = pesapi_get_env_from_ref(env_holder);
+        auto object = pesapi_get_value_from_ref(env, value_holder);
+
+        pesapi_set_property(env, object, key, pesapi_impl::Converter<T>::toScript(env, val));
+    }
+
+    bool IsValid() const
+    {
+        if (!env_holder || !value_holder)
+            return false;
+        internal::AutoValueScope ValueScope(env_holder);
+        auto env = pesapi_get_env_from_ref(env_holder);
+        auto val = pesapi_get_value_from_ref(env, value_holder);
+        return val && pesapi_is_object(env, val);
+    }
+
+    void operator=(const Object& obj)
+    {
+        env_holder = pesapi_duplicate_env_ref(obj.env_holder);
+        value_holder = pesapi_duplicate_value_ref(obj.value_holder);
+    }
+
+    pesapi_env_ref env_holder;
+    pesapi_value_ref value_holder;
+
+    friend struct pesapi_impl::Converter<Object>;
+};
+
+class Function : public Object
+{
+public:
+    Function(pesapi_env env, pesapi_value value) : Object(env, value)
+    {
+    }
+
+    template <typename... Args>
+    void Action(Args... cppArgs) const
+    {
+        if (!env_holder || !value_holder)
+            return;
+        internal::AutoValueScope ValueScope(env_holder);
+        auto env = pesapi_get_env_from_ref(env_holder);
+        auto object = pesapi_get_value_from_ref(env, value_holder);
+
+        auto _un_used = invokeHelper(env, object, cppArgs...);
+
+        if (pesapi_has_caught(ValueScope.scope))
+        {
+            REPORT_EXCEPTION(pesapi_get_exception_as_string(ValueScope.scope, true));
+        }
+    }
+
+    template <typename Ret, typename... Args>
+    Ret Func(Args... cppArgs) const
+    {
+        if (!env_holder || !value_holder)
+            return {};
+        internal::AutoValueScope ValueScope(env_holder);
+        auto env = pesapi_get_env_from_ref(env_holder);
+        auto object = pesapi_get_value_from_ref(env, value_holder);
+
+        auto ret = invokeHelper(env, object, cppArgs...);
+
+        if (pesapi_has_caught(ValueScope.scope))
+        {
+            REPORT_EXCEPTION(pesapi_get_exception_as_string(ValueScope.scope, true));
+            return {};
+        }
+        else
+        {
+            return pesapi_impl::Converter<Ret>::toCpp(env, ret);
+        }
+    }
+
+    bool IsValid() const
+    {
+        if (!env_holder || !value_holder)
+            return false;
+        internal::AutoValueScope ValueScope(env_holder);
+        auto env = pesapi_get_env_from_ref(env_holder);
+        auto val = pesapi_get_value_from_ref(env, value_holder);
+        return val && pesapi_is_function(env, val);
+    }
+
+    template <typename T>
+    void SetWeakAndOwnBy(const T* Owner)
+    {
+        internal::AutoValueScope ValueScope(env_holder);
+        auto env = pesapi_get_env_from_ref(env_holder);
+
+        auto owner = pesapi_native_object_to_value(env, StaticTypeId<T>::get(), Owner, false);
+        auto val = pesapi_get_value_from_ref(env, value_holder);
+        if (pesapi_set_owner(env, val, owner))
+        {
+            pesapi_set_ref_weak(env, value_holder);
+        }
+    }
+
+private:
+    template <typename... Args>
+    auto invokeHelper(pesapi_env env, pesapi_value func, Args... CppArgs) const
+    {
+        pesapi_value argv[sizeof...(Args)]{pesapi_impl::Converter<Args>::toScript(env, CppArgs)...};
+        return pesapi_call_function(env, func, nullptr, sizeof...(Args), argv);
+    }
+
+    auto invokeHelper(pesapi_env env, pesapi_value func) const
+    {
+        return pesapi_call_function(env, func, nullptr, 0, nullptr);
+    }
+
+    friend struct pesapi_impl::Converter<Function>;
+};
+
+}    // namespace pesapi_impl
+
+template <>
+struct ScriptTypeName<pesapi_impl::Object>
+{
+    static constexpr auto value()
+    {
+        return internal::Literal("object");
+    }
+};
+
+template <>
+struct ScriptTypeName<pesapi_impl::Function>
+{
+    static constexpr auto value()
+    {
+        return internal::Literal("Function");
+    }
+};
+
+namespace pesapi_impl
+{
+template <>
+struct Converter<Object>
+{
+    static pesapi_value toScript(pesapi_env env, Object value)
+    {
+        return pesapi_get_value_from_ref(env, value.value_holder);
+    }
+
+    static Object toCpp(pesapi_env env, pesapi_value value)
+    {
+        return Object(env, value);
+    }
+
+    static bool accept(pesapi_env env, pesapi_value value)
+    {
+        return pesapi_is_object(env, value);
+    }
+};
+
+template <>
+struct Converter<Function>
+{
+    static pesapi_value toScript(pesapi_env env, Function value)
+    {
+        return pesapi_get_value_from_ref(env, value.value_holder);
+    }
+
+    static Function toCpp(pesapi_env env, pesapi_value value)
+    {
+        return Function(env, value);
+    }
+
+    static bool accept(pesapi_env env, pesapi_value value)
+    {
+        return pesapi_is_function(env, value);
+    }
+};
+
+#include "StdFunctionConverter.hpp"
+}    // namespace pesapi_impl
+
+}    // namespace PUERTS_NAMESPACE