如何使用LuaBridge绑定已实现*/+-重载运算符的vec3类？

I've written a simple vec3 class that implements */+- operators, here's the code:

class vec3 {
public:
    vec3(): x(0.0f),y(0.0f),z(0.0f) {}
    vec3(float ix, float iy, float iz): x(ix),y(iy),z(iz) {}
    vec3 operator+(const vec3& v){ vec3 vec(x+v.x,y+v.y,z+v.z); return vec; }
    vec3 operator-(const vec3& v){ vec3 vec(x-v.x,y-v.y,z-v.z); return vec; }
    vec3 operator*(const float& s){ vec3 vec(x*s,y*s,z*s); return vec; }
    vec3 operator/(const float& d){ float div = 1.0f/d; vec3 vec(x*div,y*div,z*div); return vec; }
};

How can I use LuaBridge to bind these overloaded operators for this class?

Answer #

Great question! LuaBridge doesn’t directly support binding C++ operator overloads using their native syntax, but we can work around this by wrapping the operators as callable functions (or using lambdas) and then mapping them to Lua’s built-in metamethods—this lets you use the operators naturally in Lua just like you would in C++.

Here’s a step-by-step solution:

1. Bind the Class + Map Operators to Lua Metamethods #

Lua uses special metamethod names (like __add, __mul) to handle operator logic. We’ll use these names when binding our vec3 operators, either via helper functions or inline lambdas (the latter is more concise).

Here’s the full binding code:

#include <LuaBridge/LuaBridge.h>

void bind_vec3(lua_State* L) {
    using namespace luabridge;

    getGlobalNamespace(L)
        .beginClass<vec3>("vec3")
            // Bind constructors
            .addConstructor<void(*)()>() // Default constructor
            .addConstructor<void(*)(float, float, float)>() // 3-float constructor
            
            // Bind operators via Lua metamethods
            .addStaticFunction("__add", [](const vec3& a, const vec3& b) { return a + b; })
            .addStaticFunction("__sub", [](const vec3& a, const vec3& b) { return a - b; })
            .addStaticFunction("__mul", [](const vec3& v, float s) { return v * s; })
            // Add reverse multiplication for float * vec3 (Lua checks right-hand side for this)
            .addStaticFunction("__mul", [](float s, const vec3& v) { return v * s; })
            .addStaticFunction("__div", [](const vec3& v, float d) { return v / d; })
            
            // Optional: Bind x/y/z members for direct access in Lua
            .addData("x", &vec3::x)
            .addData("y", &vec3::y)
            .addData("z", &vec3::z)
        .endClass();
}

2. Use the Operators in Lua #

Once bound, you can use the operators exactly like you’d expect in Lua:

local v1 = vec3(1.0, 2.0, 3.0)
local v2 = vec3(4.0, 5.0, 6.0)

local sum = v1 + v2       -- Results in vec3(5.0, 7.0, 9.0)
local diff = v1 - v2      -- Results in vec3(-3.0, -3.0, -3.0)
local scaled = v1 * 2.0   -- Results in vec3(2.0, 4.0, 6.0)
local reverse_scaled = 2.0 * v1  -- Works thanks to our reverse mul binding
local divided = v1 / 2.0  -- Results in vec3(0.5, 1.0, 1.5)

print(sum.x, sum.y, sum.z) -- Outputs: 5.0 7.0 9.0

Key Notes #

• Lua Metamethods: Names like __add are Lua’s native way to handle operator logic. When you bind these, Lua automatically triggers the corresponding C++ operator when you use the + (or other) operator on vec3 objects.
• Reverse Operations: For cases like float * vec3, Lua checks if the left-hand value (a float) has a metamethod. Since it doesn’t, it falls back to checking the right-hand vec3 for a __mul that accepts a float as the first argument—hence why we bind the reverse version.
• Member Access: Binding x, y, z is optional but almost always useful for debugging and direct manipulation in Lua.

That’s all! This setup gives you seamless operator support for your vec3 class in Lua.

内容的提问来源于stack exchange，提问作者Ian Young