public SmartLuaReferance(GLua Lua, Int32 Referance)
{
this.Referance = Referance;
this.Handle = Lua;
this.Referances = 1;
this.Handle.OnClose += this.Handle_OnClose;
}
public void Push(GLua GLua, object obj)
{
if (obj is T[] val)
{
GLua.SetArray(val);
}
}
public static int Open(ref lua_State state)
{
ClientConsole.RerouteConsole();
ClientConsole.Color = new Color(0, 150, 255);
Lua = GLua.Get(state);
Lua.CreateTable();
Lua.Push <Action <string> >(Dump);
Lua.SetField(-2, "Dump");
Lua.SetField(GLua.LUA_GLOBALSINDEX, "csluaview");
var container = NativeInterface.Load <INetworkStringTableContainer>("engine", StringTableInterfaceName.CLIENT);
var tablePtr = container.FindTable("client_lua_files");
var table = JIT.ConvertInstance <INetworkStringTable>(tablePtr);
Console.WriteLine($"dotnet table ptr: {tablePtr.ToString("X8")}");
//var path0 = table.GetString(0); //hangs here
//for (int i = 0; i < table.GetNumStrings(); i++)
//{
//}
//var stringTable = StringTable.FindTable<int>("client_lua_files");
//var luaFiles = stringTable.Select(s => new LuaFile { Path = s.String, CRC = s.UserData }).ToList();
Console.WriteLine("DotNet Clientside Lua Viewer Loaded!");
return(0);
}
public void Push(GLua GLua, Object obj)
{
if (obj is CFunc func)
{
GLua.PushCFunction(func);
}
}
public void Push(GLua GLua, Object obj)
{
if (obj is Delegate dele)
{
Int32 cfunc(IntPtr L)
{
List <Object> args = new List <Object>();
foreach (ParameterInfo param in dele.Method.GetParameters())
{
args.Add(GLua.Get(param.ParameterType, param.Position + 1));
}
Object rtn = dele.DynamicInvoke(args.ToArray());
if (rtn != null)
{
GLua.Push(rtn, rtn.GetType());
return(1);
}
return(0);
}
#pragma warning disable IDE0009 // Member access should be qualified. will post issue on forums
GLua.PushCFunction(cfunc);
#pragma warning restore IDE0009
}
else
{
throw new Exception("wrapper func must be castable to delegate");
}
}
public void Push(GLua GLua, object obj)
{
if (obj is bool val)
{
GLua.LuaBase.PushBool(val);
}
}
public void Push(GLua GLua, Object obj)
{
if (obj is Boolean val)
{
GLua.LuaBase.PushBool(val);
}
}
public void Push(GLua GLua, object obj)
{
if (obj is Delegate dele)
{
CFunc cfunc = (IntPtr L) => {
List <object> args = new List <object>();
foreach (var param in dele.Method.GetParameters())
{
args.Add(GLua.Get(param.ParameterType, param.Position + 1));
}
var rtn = dele.DynamicInvoke(args.ToArray());
if (rtn != null)
{
GLua.Push(rtn, rtn.GetType());
return(1);
}
return(0);
};
GCHandle gch = GCHandle.Alloc(cfunc);
GLua.AddLuaReference(gch);
GLua.PushCFunction(cfunc);
}
else
{
throw new Exception("wrapper func must be castable to delegate");
}
}
public void Push(GLua GLua, Object obj)
{
if (obj is String str)
{
GLua.LuaBase.PushString(str, Convert.ToUInt32(str.Length));
}
}
public static Int32 Close(GLua LUA)
{
LUA.GetGlobal("print");
LUA.Push("Hello! Module is being unloaded");
LUA.Call(1, 0);
return(0);
}
public static Int32 Open(GLua LUA)
{
LUA.GetGlobal("print");
LUA.Push("Hello! Module has been loaded");
LUA.Call(1, 0);
return(0);
}
public object Get(GLua GLua, int stackPos = -1)
{
if (GLua.IsType(stackPos, LuaType.String))
{
return(GLua.LuaBase.GetString(stackPos, IntPtr.Zero));
}
return(null);
}
public void Push(GLua GLua, object obj)
{
if (obj is string)
{
var str = obj as string;
GLua.LuaBase.PushString(str, Convert.ToUInt32(str.Length));
}
}
public object Get(GLua GLua, int stackPos = -1)
{
if (GLua.IsType(stackPos, LuaType.Number))
{
return(GLua.LuaBase.GetNumber(stackPos));
}
return(null);
}
public object Get(GLua GLua, int stackPos = -1)
{
if (GLua.IsType(stackPos, LuaType.Function))
{
return(GLua.LuaBase.GetCFunction(stackPos));
}
return(null);
}
public void Push(GLua GLua, Object obj)
{
IntPtr Ptr = Marshal.AllocHGlobal(Marshal.SizeOf <Vector>());
Marshal.StructureToPtr <Vector>((Vector)obj, Ptr, false);
GLua.LuaBase.PushVector(Ptr);
Marshal.FreeHGlobal(Ptr);
}
public object Get(GLua GLua, int stackPos = -1)
{
if (GLua.IsType(stackPos, LuaType.Bool))
{
return(GLua.LuaBase.GetBool(stackPos));
}
return(null);
}
public void Push(GLua GLua, Object obj)
{
IntPtr Ptr = Marshal.AllocHGlobal(Marshal.SizeOf <Angle>());
Marshal.StructureToPtr <Angle>((Angle)obj, Ptr, true);
GLua.LuaBase.PushAngle(Ptr);
Marshal.FreeHGlobal(Ptr);
}
public Object Get(GLua GLua, Int32 stackPos = -1)
{
if (stackPos != -1)
{
throw new Exception("stackpos not implemented on array marshal");
}
return(GLua.GetArray <T>());
}
public object Get(GLua GLua, int stackPos = -1)
{
if (stackPos != -1)
{
throw new System.Exception("stackpos not implemented on array marshal");
}
GLua.GetArray <T>();
return(null);
}
public TableProxy(GLua LuaHandle, Int32 IStackPos)
{
this.LuaHandle = LuaHandle;
this.LuaHandle.Lock();
this.LuaHandle.Push(IStackPos);
this.LuaHandle.ReferenceCreate();
this.LuaHandle.Pop();
this.LuaHandle.UnLock();
}
public static Int32 Open64([MarshalAs(UnmanagedType.I8)] Int64 Ptr)
{
try
{
return(Module.Open(GLua.Get(Marshal.PtrToStructure <Lua_State64>(new IntPtr(Ptr)))));
}
catch (Exception E)
{
WriteException(E);
return(-1);
}
}
public void Push(GLua GLua, Object obj)
{
if (!(obj is Table Proxy))
{
throw new InvalidCastException();
}
if (GLua != Proxy.LuaHandle)
{
throw new InvalidOperationException("You cant transfer tables between LuaStates");
}
GLua.ReferencePush(Proxy.Referance);
}
public object Get(GLua GLua, int stackPos = -1)
{
if (stackPos != -1)
{
throw new Exception("stackpos not implemented on array marshal");
}
if (GLua.IsType(stackPos, LuaType.Table))
{
return(GLua.GetArray <T>());
}
return(null);
}
public static Int32 Close64([MarshalAs(UnmanagedType.I8)] Int64 Ptr)
{
try
{
GLua Lua = GLua.Get(Marshal.PtrToStructure <Lua_State64>(new IntPtr(Ptr)));
Int32 Ret = Module.Close(Lua);
Lua.Close();
return(Ret);
}
catch (Exception E)
{
WriteException(E);
return(-1);
}
}
public void Push(GLua GLua, object obj)
{
if (obj is string str)
{
IntPtr ptr = InteropHelp.EncodeUTF8String(str, out var handle);
try
{
GLua.LuaBase.PushString(ptr /*, Convert.ToUInt32(Encoding.UTF8.GetByteCount(str))*/);
}
finally
{
InteropHelp.FreeString(ref handle);
}
}
}
public static int Open(ref lua_State state)
{
GLua = GLua.Get(state);
GLua.CreateTable();
GLua.Push("woop was here");
GLua.SetField(-2, "var");
GLua.Push <Func <string, int, string> >(DoAThing);
GLua.SetField(-2, "wrapped");
GLua.SetField(GLua.LUA_GLOBALSINDEX, "dotnet");
Console.WriteLine("DotNet loaded");
return(0);
}
public Color(GLua gLua, Int32 IStackPos)
{
Boolean B = gLua.Lock();
gLua.GetField(IStackPos, "r");
this.R = (Byte)gLua.LuaBase.GetNumber(-1);
gLua.GetField(IStackPos, "g");
this.G = (Byte)gLua.LuaBase.GetNumber(-1);
gLua.GetField(IStackPos, "b");
this.B = (Byte)gLua.LuaBase.GetNumber(-1);
gLua.GetField(IStackPos, "a");
this.A = (Byte)gLua.LuaBase.GetNumber(-1);
gLua.Pop(4);
if (B)
{
gLua.UnLock();
}
}
internal void Inject(GLua vm)
{
if (ObjectType != "")
{
var ptr = Lua.lua_newuserdata(vm, 8);
Marshal.Copy(BitConverter.GetBytes(Index), 0, ptr, 8);
Pointer = ptr;
Lua.luaL_getmetatable(vm, ObjectType);
Lua.lua_setmetatable(vm, -2);
}else
{
var ptr = Lua.lua_newuserdata(vm, 8);
Marshal.Copy(BitConverter.GetBytes(Index), 0, ptr, 8);
Pointer = ptr;
}
Created = true;
}
public void Push(GLua gLua)
{
Boolean B = gLua.Lock();
gLua.LuaBase.CreateTable();
gLua.LuaBase.PushNumber(this.R);
gLua.LuaBase.SetField(-2, "r");
gLua.LuaBase.PushNumber(this.G);
gLua.LuaBase.SetField(-2, "g");
gLua.LuaBase.PushNumber(this.B);
gLua.LuaBase.SetField(-2, "b");
gLua.LuaBase.PushNumber(this.A);
gLua.LuaBase.SetField(-2, "a");
gLua.LuaBase.CreateMetaTable("COLOR");
gLua.LuaBase.SetMetaTable(-2);
if (B)
{
gLua.UnLock();
}
}
private int OnCallOverloads(GLua vm)
{
int argc = Lua.lua_gettop(vm);
foreach (var cb in Overloads.Where(cb => cb.CanCall(vm, argc)))
{
return cb.OnCall(vm);
}
return OnCall(vm, true);
}
bool CanCall(GLua vm, int count)
{
if (Method.GetParameters().Length != count) // fixme 'params' support
return false;
for (int i = 0; i < count; i++)
{
var param = Method.GetParameters()[i];
var luaParamType = Lua.lua_type(vm, i+1);
switch (luaParamType)
{
case Lua.LUA_TNUMBER:
if (param.ParameterType != typeof(int)
&& param.ParameterType != typeof(uint)
&& param.ParameterType != typeof(short)
&& param.ParameterType != typeof(ushort)
&& param.ParameterType != typeof(ulong)
&& param.ParameterType != typeof(float)
&& param.ParameterType != typeof(double)
&& param.ParameterType != typeof(decimal)
&& param.ParameterType != typeof(sbyte)
&& param.ParameterType != typeof(byte)
&& !param.ParameterType.IsEnum)
return false;
break;
case Lua.LUA_TSTRING:
if (param.ParameterType != typeof(string))
return false;
break;
case Lua.LUA_TBOOLEAN:
if (param.ParameterType != typeof(bool))
return false;
break;
case Lua.LUA_TUSERDATA:
if (vm.DataStore.GetObject(i+1) == null || param.ParameterType != vm.DataStore.GetObject(i+1).GetType())
return false;
break;
}
}
return true;
}
public CNewParticleEffect(GLua LuaHandle, Int32 IStackPos) : base(LuaHandle, IStackPos)
{
}
protected void PushResult(GLua vm, object result)
{
if (result is string)
{
Lua.lua_pushstring(vm, (string)result);
}
else if (result is bool)
{
if ((bool)result)
Lua.lua_pushboolean(vm, 1);
else
Lua.lua_pushboolean(vm, 0);
}
else if (result is int)
{
Lua.lua_pushinteger(vm, (int)result);
}
else if (result is double)
{
Lua.lua_pushnumber(vm, (double)result);
}
else if (result is float)
{
Lua.lua_pushnumber(vm, (float)result);
}
else if (result is GluedData)
{
var ud = result as GluedData;
if (!ud.Created)
{
ud.Inject(vm);
}
}
else if (result is IGLuaObject)
{
vm.DataStore.Create(result, ((IGLuaObject)result).ObjectType);
}
else if (result != null)
{
vm.DataStore.Create(result, result.GetType().FullName);
}
}
