sluaunreal

slua-unreal provides three different technical methods for binding Lua interfaces to C++, allowing you to choose between ease of use and performance:

1. Blueprint Reflection (蓝图反射方法): Uses Unreal's built-in reflection system. It is the easiest to use but has the lowest performance.
2. Static Code Generation (静态代码生成): Uses dot-clang (based on libclang) to automatically generate C++ code for bindings. This is highly performant.
3. CppBinding (模板展开): Involves manually writing binding code using template expansion. This offers performance equivalent to static code generation.

Performance Comparison Summary:

• CppBinding is an order of magnitude faster than Blueprint Reflection.
• Static Code Generation and CppBinding have nearly identical performance characteristics.
• For common classes like FVector, static generation code is already included in the repository.

Slua-unreal provides a comprehensive suite of features for integrating Lua with Unreal Engine:

• API Exporting: Automatic export of Blueprint APIs, support for Enums, and non-blueprint classes like FVector (with operator overloading).
• Functionality: Support for RPC (Remote Procedure Call) functions, overriding Blueprint functions with Lua, and using Lua functions as callbacks for Blueprint events.
• C++ Integration: Exporting normal C++ functions/classes via templates or code generation, and manual addition of non-blueprint functions to UObject (e.g., GetWidgetFromName).
• Communication: Two-way calling between Blueprint and Lua, including support for out parameters (C++ non-const references).
• Robustness & Performance: Dead loop detection/reporting, multi-state support for different environments, CPU profiling, and multi-threaded Lua Garbage Collection (GC).
• Debugging: Specialized VS Code debugger support for in-device debugging, breakpoints, variable inspection, and IntelliSense.

Use the import function to bring Blueprint classes into Lua. You can then instantiate classes, load UI, and handle events.

-- import blueprint class to use
local Button = import('Button');
local ButtonStyle = import('ButtonStyle');
local TextBlock = import('TextBlock');
local SluaTestCase=import('SluaTestCase');

-- call static function of uclass
SluaTestCase.StaticFunc()

-- create Button
local btn=Button();
local txt=TextBlock();

-- load panel of blueprint
local ui=slua.loadUI('/Game/Panel.Panel');

-- add to show
ui:AddToViewport(0);

-- find sub widget from the panel
local btn2=ui:FindWidget('Button1');
local index = 1

-- handle click event
btn2.OnClicked:Add(function() 
    index=index+1
    print('say helloworld',index) 
end);

-- handle text changed event
local edit=ui:FindWidget('TextBox_0');
local evt=edit.OnTextChanged:Add(function(txt) print('text changed',txt) end);

-- use FVector and operator overloading
local p = actor:K2_GetActorLocation()
local h = HitResult()
local v = FVector(math.sin(tt)*100,2,3)
local offset = FVector(0,math.cos(tt)*50,0)
local ok,h=actor:K2_SetActorLocation(v+offset,true,h,true)

Slua 2.0 supports class inheritance in Lua. You can use __super to call functions from a parent class, and self.Super to call functions from the Blueprint parent.

-- LuaActor.lua
local LuaActor ={}

-- override event from blueprint
function LuaActor:ReceiveBeginPlay()
    self.bCanEverTick = true
    -- set bCanBeDamaged property in parent
    self.bCanBeDamaged = false
    print("actor:ReceiveBeginPlay")
end

function LuaActor:ReceiveEndPlay(reason)
    print("actor:ReceiveEndPlay",reason)
end

return Class(nil, nil, LuaActor)

-- LuaBpActor.lua
local LuaBpActor = {}

-- override event from blueprint
function LuaBpActor:ReceiveBeginPlay()
    print("bpactor:ReceiveBeginPlay")
    -- call LuaActor super ReceiveBeginPlay
    LuaBpActor.__super.ReceiveBeginPlay(self)
    
    -- call blueprint super ReceiveBeginPlay
    self.Super:ReceiveBeginPlay()
end

local CLuaActor = require("LuaActor")
-- CLuaActor is base class
return Class(CLuaActor, nil, LuaBpActor)

You can define RPC (Remote Procedure Call) functions directly in Lua by specifying them in ServerRPC, ClientRPC, or MulticastRPC tables. You must define the Params list using EPropertyClass types.

-- LuaActor.lua
local LuaActor = 
{
    ServerRPC = {},     -- C2S RPC list
    ClientRPC = {},     -- S2C RPC list
    MulticastRPC = {},  -- NetMulticast RPC list
}

local EPropertyClass = import("EPropertyClass")

LuaActor.ServerRPC.TestServerRPC = {
    Reliable = true, 
    Params = 
    {
        EPropertyClass.Int, 
        EPropertyClass.Str, 
        EPropertyClass.bool, 
    }
}

-- ... (ClientRPC and MulticastRPC follow same pattern)

function LuaActor:TestServerRPC(ArgInt, ArgStr, ArgBool)
    -- implementation
end

function LuaActor:TestClientRPC(ArgInt, ArgStr, ArgBool)
    -- implementation
end

function LuaActor:TestMulticastRPC(ArgInt, ArgStr, ArgBool)
    -- implementation
end

-- LuaActor.lua
local LuaActor = 
{
    ServerRPC = {},     -- C2S类RPC列表，类似UFUNCTION宏中的Server
    ClientRPC = {},     -- S2C类RPC列表，类似UFUNCTION宏中的Client
    MulticastRPC = {},  -- 多播类RPC列表，类似UFUNCTION宏中的NetMulticast
}

local EPropertyClass = import("EPropertyClass")

LuaActor.ServerRPC.TestServerRPC = {
    -- 是否可靠RPC
    Reliable = true, 
    -- 定义参数列表
    Params = 
    {
        EPropertyClass.Int, 
        EPropertyClass.Str, 
        EPropertyClass.bool, 
    }
}

LuaActor.ClientRPC.TestClientRPC = {
    -- 是否可靠RPC
    Reliable = true, 
    -- 定义参数列表
    Params = 
    {
        EPropertyClass.Int, 
        EPropertyClass.Str, 
        EPropertyClass.bool, 
    }
}

LuaActor.MulticastRPC.TestMulticastRPC = {
    -- 是否可靠RPC
    Reliable = true, 
    -- 定义参数列表
    Params = 
    {
        EPropertyClass.Int, 
        EPropertyClass.Str, 
        EPropertyClass.bool, 
    }
}

function LuaActor:TestServerRPC(ArgInt, ArgStr, ArgBool)
    
end

function LuaActor:TestClientRPC(ArgInt, ArgStr, ArgBool)
    
end

function LuaActor:TestMulticastRPC(ArgInt, ArgStr, ArgBool)
    
end

Slua 2.0 supports defining property replication information (for networking) in Lua via GetLifetimeReplicatedProps. You can specify replication conditions (e.g., COND_InitialOnly, COND_OwnerOnly) and types (including arrays).

-- LuaActor.lua
local LuaActor ={}

function LuaActor:GetLifetimeReplicatedProps()
    local ELifetimeCondition = import("ELifetimeCondition")
    local FVectorType = import("Vector")
    return {
        { "Name", ELifetimeCondition.COND_InitialOnly, EPropertyClass.Str},
        { "HP", ELifetimeCondition.COND_OwnerOnly, EPropertyClass.Float},
        { "Position", ELifetimeCondition.COND_SimulatedOnly, FVectorType},
        { "TeamateNameList", ELifetimeCondition.COND_None, EPropertyClass.Array, EPropertyClass.Str},
        { "TeamatePositions", ELifetimeCondition.COND_None, EPropertyClass.Array, FVectorType},
    }
end

return Class(nil, nil, LuaActor)