Merge branch 'lua_context_api' into 'master'

Remove getRealFrameDuration in global context, context caching helpers

See merge request OpenMW/openmw!4273

apps/openmw/mwlua/context.hpp

@@ -1,6 +1,8 @@
 #ifndef MWLUA_CONTEXT_H
 #define MWLUA_CONTEXT_H
 
+#include <components/lua/luastate.hpp>
+
 namespace LuaUtil
 {
     class LuaState;
@@ -15,13 +17,83 @@ namespace MWLua
 
     struct Context
     {
-        bool mIsMenu;
+        enum Type
-        bool mIsGlobal;
+        {
+            Menu,
+            Global,
+            Local,
+        };
+        Type mType;
         LuaManager* mLuaManager;
         LuaUtil::LuaState* mLua;
         LuaUtil::UserdataSerializer* mSerializer;
         ObjectLists* mObjectLists;
         LuaEvents* mLuaEvents;
+
+        std::string_view typeName() const
+        {
+            switch (mType)
+            {
+                case Menu:
+                    return "menu";
+                case Global:
+                    return "global";
+                case Local:
+                    return "local";
+                default:
+                    throw std::domain_error("Unhandled context type");
+            }
+        }
+
+        template <class... Str>
+        sol::object getCachedPackage(std::string_view first, const Str&... str) const
+        {
+            sol::object package = mLua->sol()[first];
+            if constexpr (sizeof...(str) == 0)
+                return package;
+            else
+                return LuaUtil::getFieldOrNil(package, str...);
+        }
+
+        template <class... Str>
+        const sol::object& setCachedPackage(const sol::object& value, std::string_view first, const Str&... str) const
+        {
+            sol::state_view& lua = mLua->sol();
+            if constexpr (sizeof...(str) == 0)
+                lua[first] = value;
+            else
+            {
+                if (lua[first] == sol::nil)
+                    lua[first] = sol::table(lua, sol::create);
+                sol::table table = lua[first];
+                LuaUtil::setDeepField(table, value, str...);
+            }
+            return value;
+        }
+
+        sol::object getTypePackage(std::string_view key) const { return getCachedPackage(key, typeName()); }
+
+        const sol::object& setTypePackage(const sol::object& value, std::string_view key) const
+        {
+            return setCachedPackage(value, key, typeName());
+        }
+
+        template <class Factory>
+        sol::object cachePackage(std::string_view key, Factory factory) const
+        {
+            sol::object cached = getCachedPackage(key);
+            if (cached != sol::nil)
+                return cached;
+            else
+                return setCachedPackage(factory(), key);
+        }
+
+        bool initializeOnce(std::string_view key) const
+        {
+            sol::object flag = mLua->sol()[key];
+            mLua->sol()[key] = sol::make_object(mLua->sol(), true);
+            return flag == sol::nil;
+        }
     };
 
 }

apps/openmw/mwlua/corebindings.cpp

@@ -64,16 +64,18 @@ namespace MWLua
         api["getRealTime"] = []() {
             return std::chrono::duration<double>(std::chrono::steady_clock::now().time_since_epoch()).count();
         };
-        // TODO: remove in global context?
+
-        api["getRealFrameDuration"] = []() { return MWBase::Environment::get().getFrameDuration(); };
+        if (context.mType != Context::Global)
+            api["getRealFrameDuration"] = []() { return MWBase::Environment::get().getFrameDuration(); };
     }
 
     sol::table initCorePackage(const Context& context)
     {
         auto* lua = context.mLua;
 
-        if (lua->sol()["openmw_core"] != sol::nil)
+        sol::object cached = context.getTypePackage("openmw_core");
-            return lua->sol()["openmw_core"];
+        if (cached != sol::nil)
+            return cached;
 
         sol::table api(lua->sol(), sol::create);
         api["API_REVISION"] = Version::getLuaApiRevision(); // specified in CMakeLists.txt
@@ -81,13 +83,7 @@ namespace MWLua
             Log(Debug::Warning) << "Quit requested by a Lua script.\n" << lua->debugTraceback();
             MWBase::Environment::get().getStateManager()->requestQuit();
         };
-        api["sendGlobalEvent"] = [context](std::string eventName, const sol::object& eventData) {
-            context.mLuaEvents->addGlobalEvent(
-                { std::move(eventName), LuaUtil::serialize(eventData, context.mSerializer) });
-        };
         api["contentFiles"] = initContentFilesBindings(lua->sol());
-        api["sound"] = initCoreSoundBindings(context);
-        api["vfx"] = initCoreVfxBindings(context);
         api["getFormId"] = [](std::string_view contentFile, unsigned int index) -> std::string {
             const std::vector<std::string>& contentList = MWBase::Environment::get().getWorld()->getContentFiles();
             for (size_t i = 0; i < contentList.size(); ++i)
@@ -96,12 +92,19 @@ namespace MWLua
             throw std::runtime_error("Content file not found: " + std::string(contentFile));
         };
         addCoreTimeBindings(api, context);
-        api["magic"] = initCoreMagicBindings(context);
-        api["stats"] = initCoreStatsBindings(context);
 
-        api["factions"] = initCoreFactionBindings(context);
+        api["magic"]
-        api["dialogue"] = initCoreDialogueBindings(context);
+            = context.cachePackage("openmw_core_magic", [context]() { return initCoreMagicBindings(context); });
-        api["l10n"] = LuaUtil::initL10nLoader(lua->sol(), MWBase::Environment::get().getL10nManager());
+
+        api["stats"]
+            = context.cachePackage("openmw_core_stats", [context]() { return initCoreStatsBindings(context); });
+
+        api["factions"]
+            = context.cachePackage("openmw_core_factions", [context]() { return initCoreFactionBindings(context); });
+        api["dialogue"]
+            = context.cachePackage("openmw_core_dialogue", [context]() { return initCoreDialogueBindings(context); });
+        api["l10n"] = context.cachePackage("openmw_core_l10n",
+            [lua]() { return LuaUtil::initL10nLoader(lua->sol(), MWBase::Environment::get().getL10nManager()); });
         const MWWorld::Store<ESM::GameSetting>* gmstStore
             = &MWBase::Environment::get().getESMStore()->get<ESM::GameSetting>();
         api["getGMST"] = [lua = context.mLua, gmstStore](const std::string& setting) -> sol::object {
@@ -126,25 +129,29 @@ namespace MWLua
             return sol::nil;
         };
 
-        lua->sol()["openmw_core"] = LuaUtil::makeReadOnly(api);
+        if (context.mType != Context::Menu)
-        return lua->sol()["openmw_core"];
+        {
-    }
+            api["sendGlobalEvent"] = [context](std::string eventName, const sol::object& eventData) {
+                context.mLuaEvents->addGlobalEvent(
+                    { std::move(eventName), LuaUtil::serialize(eventData, context.mSerializer) });
+            };
+            api["sound"]
+                = context.cachePackage("openmw_core_sound", [context]() { return initCoreSoundBindings(context); });
+            api["vfx"] = initCoreVfxBindings(context);
+        }
+        else
+        {
+            api["sendGlobalEvent"] = [context](std::string eventName, const sol::object& eventData) {
+                if (MWBase::Environment::get().getStateManager()->getState() == MWBase::StateManager::State_NoGame)
+                {
+                    throw std::logic_error("Can't send global events when no game is loaded");
+                }
+                context.mLuaEvents->addGlobalEvent(
+                    { std::move(eventName), LuaUtil::serialize(eventData, context.mSerializer) });
+            };
+        }
 
-    sol::table initCorePackageForMenuScripts(const Context& context)
+        sol::table readOnly = LuaUtil::makeReadOnly(api);
-    {
+        return context.setTypePackage(readOnly, "openmw_core");
-        sol::table api(context.mLua->sol(), sol::create);
-        for (auto& [k, v] : LuaUtil::getMutableFromReadOnly(initCorePackage(context)))
-            api[k] = v;
-        api["sendGlobalEvent"] = [context](std::string eventName, const sol::object& eventData) {
-            if (MWBase::Environment::get().getStateManager()->getState() == MWBase::StateManager::State_NoGame)
-            {
-                throw std::logic_error("Can't send global events when no game is loaded");
-            }
-            context.mLuaEvents->addGlobalEvent(
-                { std::move(eventName), LuaUtil::serialize(eventData, context.mSerializer) });
-        };
-        api["sound"] = sol::nil;
-        api["vfx"] = sol::nil;
-        return LuaUtil::makeReadOnly(api);
     }
 }

apps/openmw/mwlua/corebindings.hpp

@@ -10,10 +10,6 @@ namespace MWLua
     void addCoreTimeBindings(sol::table& api, const Context& context);
 
     sol::table initCorePackage(const Context&);
-
-    // Returns `openmw.core`, but disables the functionality that shouldn't
-    // be availabe in menu scripts (to prevent cheating in mutiplayer via menu console).
-    sol::table initCorePackageForMenuScripts(const Context&);
 }
 
 #endif // MWLUA_COREBINDINGS_H

apps/openmw/mwlua/luabindings.cpp

@@ -80,7 +80,7 @@ namespace MWLua
     std::map<std::string, sol::object> initMenuPackages(const Context& context)
     {
         return {
-            { "openmw.core", initCorePackageForMenuScripts(context) },
+            { "openmw.core", initCorePackage(context) },
             { "openmw.ambient", initAmbientPackage(context) },
             { "openmw.ui", initUserInterfacePackage(context) },
             { "openmw.menu", initMenuPackage(context) },

apps/openmw/mwlua/luamanagerimp.cpp

@@ -83,25 +83,24 @@ namespace MWLua
 
     void LuaManager::init()
     {
-        Context context;
+        Context globalContext;
-        context.mIsMenu = false;
+        globalContext.mType = Context::Global;
-        context.mIsGlobal = true;
+        globalContext.mLuaManager = this;
-        context.mLuaManager = this;
+        globalContext.mLua = &mLua;
-        context.mLua = &mLua;
+        globalContext.mObjectLists = &mObjectLists;
-        context.mObjectLists = &mObjectLists;
+        globalContext.mLuaEvents = &mLuaEvents;
-        context.mLuaEvents = &mLuaEvents;
+        globalContext.mSerializer = mGlobalSerializer.get();
-        context.mSerializer = mGlobalSerializer.get();
+
-
+        Context localContext = globalContext;
-        Context localContext = context;
+        localContext.mType = Context::Local;
-        localContext.mIsGlobal = false;
         localContext.mSerializer = mLocalSerializer.get();
 
-        Context menuContext = context;
+        Context menuContext = globalContext;
-        menuContext.mIsMenu = true;
+        menuContext.mType = Context::Menu;
 
-        for (const auto& [name, package] : initCommonPackages(context))
+        for (const auto& [name, package] : initCommonPackages(globalContext))
             mLua.addCommonPackage(name, package);
-        for (const auto& [name, package] : initGlobalPackages(context))
+        for (const auto& [name, package] : initGlobalPackages(globalContext))
             mGlobalScripts.addPackage(name, package);
         for (const auto& [name, package] : initMenuPackages(menuContext))
             mMenuScripts.addPackage(name, package);

apps/openmw/mwlua/uibindings.cpp

@@ -80,8 +80,10 @@ namespace MWLua
         }();
     }
 
-    sol::table registerUiApi(const Context& context, bool menu)
+    sol::table registerUiApi(const Context& context)
     {
+        bool menu = context.mType == Context::Menu;
+
         MWBase::WindowManager* windowManager = MWBase::Environment::get().getWindowManager();
 
         sol::table api = context.mLua->newTable();
@@ -293,51 +295,47 @@ namespace MWLua
 
     sol::table initUserInterfacePackage(const Context& context)
     {
-        std::string_view menuCache = "openmw_ui_menu";
+        if (context.initializeOnce("openmw_ui_usertypes"))
-        std::string_view gameCache = "openmw_ui_game";
-        std::string_view cacheKey = context.mIsMenu ? menuCache : gameCache;
         {
-            sol::state_view& lua = context.mLua->sol();
+            auto element = context.mLua->sol().new_usertype<LuaUi::Element>("UiElement");
-            if (lua[cacheKey] != sol::nil)
+            element[sol::meta_function::to_string] = [](const LuaUi::Element& element) {
-                return lua[cacheKey];
+                std::stringstream res;
-        }
+                res << "UiElement";
-
+                if (element.mLayer != "")
-        auto element = context.mLua->sol().new_usertype<LuaUi::Element>("UiElement");
+                    res << "[" << element.mLayer << "]";
-        element[sol::meta_function::to_string] = [](const LuaUi::Element& element) {
+                return res.str();
-            std::stringstream res;
+            };
-            res << "UiElement";
+            element["layout"] = sol::property([](const LuaUi::Element& element) { return element.mLayout; },
-            if (element.mLayer != "")
+                [](LuaUi::Element& element, const sol::table& layout) { element.mLayout = layout; });
-                res << "[" << element.mLayer << "]";
+            element["update"] = [luaManager = context.mLuaManager](const std::shared_ptr<LuaUi::Element>& element) {
-            return res.str();
+                if (element->mState != LuaUi::Element::Created)
-        };
+                    return;
-        element["layout"] = sol::property([](const LuaUi::Element& element) { return element.mLayout; },
+                element->mState = LuaUi::Element::Update;
-            [](LuaUi::Element& element, const sol::table& layout) { element.mLayout = layout; });
+                luaManager->addAction([element] { wrapAction(element, [&] { element->update(); }); }, "Update UI");
-        element["update"] = [luaManager = context.mLuaManager](const std::shared_ptr<LuaUi::Element>& element) {
+            };
-            if (element->mState != LuaUi::Element::Created)
+            element["destroy"] = [luaManager = context.mLuaManager](const std::shared_ptr<LuaUi::Element>& element) {
-                return;
+                if (element->mState == LuaUi::Element::Destroyed)
-            element->mState = LuaUi::Element::Update;
+                    return;
-            luaManager->addAction([element] { wrapAction(element, [&] { element->update(); }); }, "Update UI");
+                element->mState = LuaUi::Element::Destroy;
-        };
+                luaManager->addAction(
-        element["destroy"] = [luaManager = context.mLuaManager](const std::shared_ptr<LuaUi::Element>& element) {
+                    [element] { wrapAction(element, [&] { LuaUi::Element::erase(element.get()); }); }, "Destroy UI");
-            if (element->mState == LuaUi::Element::Destroyed)
+            };
-                return;
-            element->mState = LuaUi::Element::Destroy;
-            luaManager->addAction(
-                [element] { wrapAction(element, [&] { LuaUi::Element::erase(element.get()); }); }, "Destroy UI");
-        };
-
-        auto uiLayer = context.mLua->sol().new_usertype<LuaUi::Layer>("UiLayer");
-        uiLayer["name"] = sol::readonly_property([](LuaUi::Layer& self) -> std::string_view { return self.name(); });
-        uiLayer["size"] = sol::readonly_property([](LuaUi::Layer& self) { return self.size(); });
-        uiLayer[sol::meta_function::to_string]
-            = [](LuaUi::Layer& self) { return Misc::StringUtils::format("UiLayer(%s)", self.name()); };
 
-        sol::table menuApi = registerUiApi(context, true);
+            auto uiLayer = context.mLua->sol().new_usertype<LuaUi::Layer>("UiLayer");
-        sol::table gameApi = registerUiApi(context, false);
+            uiLayer["name"]
+                = sol::readonly_property([](LuaUi::Layer& self) -> std::string_view { return self.name(); });
+            uiLayer["size"] = sol::readonly_property([](LuaUi::Layer& self) { return self.size(); });
+            uiLayer[sol::meta_function::to_string]
+                = [](LuaUi::Layer& self) { return Misc::StringUtils::format("UiLayer(%s)", self.name()); };
+        }
 
-        sol::state_view& lua = context.mLua->sol();
+        sol::object cached = context.getTypePackage("openmw_ui");
-        lua[menuCache] = LuaUtil::makeReadOnly(menuApi);
+        if (cached != sol::nil)
-        lua[gameCache] = LuaUtil::makeReadOnly(gameApi);
+            return cached;
-        return lua[cacheKey];
+        else
+        {
+            sol::table api = LuaUtil::makeReadOnly(registerUiApi(context));
+            return context.setTypePackage(api, "openmw_ui");
+        }
     }
 }

components/lua/luastate.hpp

@@ -265,6 +265,20 @@ namespace LuaUtil
             return getFieldOrNil(value, str...);
     }
 
+    template <class... Str>
+    void setDeepField(sol::table& table, const sol::object& value, std::string_view first, const Str&... str)
+    {
+        if constexpr (sizeof...(str) == 0)
+            table[first] = value;
+        else
+        {
+            if (table[first] == sol::nil)
+                table[first] = sol::table(table.lua_state(), sol::create);
+            sol::table nextTable = table[first];
+            setDeepField(nextTable, value, str...);
+        }
+    }
+
     // String representation of a Lua object. Should be used for debugging/logging purposes only.
     std::string toString(const sol::object&);
 

files/lua_api/openmw/core.lua

@@ -52,7 +52,7 @@
 -- @return #number
 
 ---
--- Frame duration in seconds
+-- Frame duration in seconds. Not available in global scripts.
 -- @function [parent=#core] getRealFrameDuration
 -- @return #number
 

files/lua_api/openmw/world.lua

@@ -118,11 +118,6 @@
 -- @function [parent=#world] setGameTimeScale
 -- @param #number ratio
 
----
--- Frame duration in seconds
--- @function [parent=#world] getRealFrameDuration
--- @return #number
-
 ---
 -- Whether the world is paused (onUpdate doesn't work when the world is paused).
 -- @function [parent=#world] isWorldPaused