Accessing Lua self object from a C++ function

[akovachev]

I need to call a Lua function attached to the object instance from C++ class member function.

In other words I need to pass the self object to the function when calling from C++. If I know the name of the object I can access it by state["objectName"] and pass it. But unless I cache it somewhere I can't really convert this pointer to self object. I'm looking for an elegant mechanism to do this as I have a ton of bound C++ classes that need to call custom functions.

Ideally I'd want to do this at construction time. Perhaps by getting access to the Lua table object as a constructor parameter? Would that even work, or is the table created after the object has been constructed?

class Cpp { public: ... void callLuaMemberFunction { if (luaMemberFunc) { luaMemberFunc(, params...); } }

void bindLuaFunction(const std::string& key, sol::function func) { if (key == "memberFunc") { luaMemberFunc = std::move(func); } // ... [Handle other overridable functions similarly] }

private: sol::function luaMemberFunc; }

at binding time:

cpp.set(sol::meta_function::new_index, [](Cpp& _this, const std::string& key, sol::function func) { _this.bindLuaFunction(key, func); });

Lua:

cpp = Cpp() cpp:memberFunc = function(...) end

Currently I'm solving this by passing the name to the object at construction which then looks up the object by name every call. A typo could be an issue if we pass a different name than the object's assigned name. Something I'd like to avoid. I also want to avoid caching the object for each Lua member function (I'm assuming I'd have access to it at new_index call).

[Rochet2]

Would something like this work for you?

#define SOL_ALL_SAFETIES_ON 1
#include <sol/sol.hpp>

struct Cpp {
};

int main() {
    sol::state lua;
    lua.open_libraries(sol::lib::base, sol::lib::package);

    auto cpp_meta = lua.new_usertype<Cpp>("Cpp");

    lua.script(R"(
        Cpp.memberFunc = function(...)
            print(...)
        end

        cpp = Cpp.new()
        cpp:memberFunc("hello world!")
        -- prints sol.Cpp: 0x5b0038	hello world!
    )");
    return 0;
}

Its not what you ask, but it achieves what you set out to do in your code example from what I see.

[akovachev]

@Rochet2 Thank you for your suggestion.

However the goal is cpp:memberFunction to be called from the C++ class such that the Lua implementation has access to the Lua self table. I know I can pass in the C++ this pointer but that won’t ensure access to the self object.

On Sun, Dec 3, 2023 at 12:30 PM Rochet2 @.***> wrote:

Would something like this work for you?

#define SOL_ALL_SAFETIES_ON 1 #include <sol/sol.hpp> struct Cpp { }; int main() { sol::state lua; lua.open_libraries(sol::lib::base, sol::lib::package);

auto cpp_meta = lua.new_usertype<Cpp>("Cpp");

lua.script(R"(        Cpp.memberFunc = function(...)            print(...)        end        cpp = Cpp.new()        cpp:memberFunc("hello world!")    )");
return 0;

}

Its not what you ask, but it achieves what you set out to do in your code example from what I see.

— Reply to this email directly, view it on GitHub https://github.com/ThePhD/sol2/issues/1559#issuecomment-1837436914, or unsubscribe https://github.com/notifications/unsubscribe-auth/AAZKSUCE2KYGS4NUDHAOLHTYHRIFDAVCNFSM6AAAAABAEUFCKWVHI2DSMVQWIX3LMV43OSLTON2WKQ3PNVWWK3TUHMYTQMZXGQZTMOJRGQ . You are receiving this because you authored the thread.Message ID: @.***>

[akovachev]

In short I need something like returns_self, but instead of returning it, for it to be passed in as sol::object or sol::reference to a bound member function.

Attaching one of the tests using returns_self from sol::policies:

TEST_CASE("policies/self", "ensure we return a direct reference to the lua userdata rather than creating a new one") {
	struct vec2 {
		float x = 20.f;
		float y = 20.f;

		vec2& normalize() {
			float len2 = x * x + y * y;
			if (len2 != 0) {
				float len = sqrtf(len2);
				x /= len;
				y /= len;
			}
			return *this;
		}

		~vec2() {
			x = std::numeric_limits<float>::lowest();
			y = std::numeric_limits<float>::lowest();
		}
	};

	sol::state lua;
	lua.open_libraries(sol::lib::base);

	lua.new_usertype<vec2>("vec2", "x", &vec2::x, "y", &vec2::y, "normalize", sol::policies(&vec2::normalize, sol::returns_self()));

	auto result1 = lua.safe_script(R"(
v1 = vec2.new()
print('v1:', v1.x, v1.y)
v2 = v1:normalize()
print('v1:', v1.x, v1.y)
print('v2:', v2.x, v2.y)
print(v1, v2)
assert(rawequal(v1, v2))
v1 = nil
collectgarbage()
print(v2) -- v2 points to same, is not destroyed
		)",
	     sol::script_pass_on_error);
	REQUIRE(result1.valid());
}

[akovachev]

I think I found the solution, it's not super obvious, but there is a working example:

https://github.com/ThePhD/sol2/blob/develop/examples/source/self_from_lua.cpp

The key is to dig inside the state's stack using this_state (from the example above):

		thing(sol::this_state ts) {
			lua_State* L = ts;
			// references the object that called this function
			// in constructors:
			sol::stack_object selfobj(L, 1);

			// definitely the same
			thing& self = selfobj.as<thing>();
			SOL_ASSERT(&self == this);
		}

		void func(sol::this_state ts) const {
			lua_State* L = ts;
			// references the object that called this function
			// in regular member functions:
			sol::stack_object selfobj(L, 1);
			// "1" is the bottom of the Lua stack
			// 2 is one up, so on and so forth...
			thing& self = selfobj.as<thing>();

			// definitely the same
			SOL_ASSERT(&self == this);
		}