2911 lines
93 KiB
C#
2911 lines
93 KiB
C#
/*
|
|
Copyright (c) 2015-2017 topameng(topameng@qq.com)
|
|
|
|
Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
of this software and associated documentation files (the "Software"), to deal
|
|
in the Software without restriction, including without limitation the rights
|
|
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
copies of the Software, and to permit persons to whom the Software is
|
|
furnished to do so, subject to the following conditions:
|
|
|
|
The above copyright notice and this permission notice shall be included in all
|
|
copies or substantial portions of the Software.
|
|
|
|
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
SOFTWARE.
|
|
*/
|
|
using UnityEngine;
|
|
using System;
|
|
using System.Diagnostics;
|
|
using System.IO;
|
|
using System.Collections.Generic;
|
|
using System.Collections;
|
|
using System.Runtime.InteropServices;
|
|
using System.Text;
|
|
|
|
#if UNITY_EDITOR
|
|
using UnityEditor;
|
|
using UnityEditor.Callbacks;
|
|
using System.Reflection;
|
|
#endif
|
|
|
|
namespace LuaInterface
|
|
{
|
|
public static class ToLua
|
|
{
|
|
public delegate object LuaTableToVar(IntPtr L, int pos);
|
|
public delegate void LuaPushVarObject(IntPtr L, object o);
|
|
static Type monoType = typeof(Type).GetType();
|
|
static public LuaTableToVar[] ToVarMap = new LuaTableToVar[LuaValueType.Max];
|
|
static public Dictionary<Type, LuaPushVarObject> VarPushMap = new Dictionary<Type, LuaPushVarObject>();
|
|
|
|
#if UNITY_EDITOR
|
|
static int _instanceID = -1;
|
|
static int _line = 201;
|
|
private static object consoleWindow;
|
|
private static object logListView;
|
|
private static FieldInfo logListViewCurrentRow;
|
|
private static MethodInfo LogEntriesGetEntry;
|
|
private static object logEntry;
|
|
private static FieldInfo logEntryCondition;
|
|
#endif
|
|
|
|
static ToLua()
|
|
{
|
|
ToVarMap[LuaValueType.Vector3] = ToObjectVec3;
|
|
ToVarMap[LuaValueType.Quaternion] = ToObjectQuat;
|
|
ToVarMap[LuaValueType.Vector2] = ToObjectVec2;
|
|
ToVarMap[LuaValueType.Color] = ToObjectColor;
|
|
ToVarMap[LuaValueType.Vector4] = ToObjectVec4;
|
|
ToVarMap[LuaValueType.Ray] = ToObjectRay;
|
|
ToVarMap[LuaValueType.LayerMask] = ToObjectLayerMask;
|
|
ToVarMap[LuaValueType.Bounds] = ToObjectBounds;
|
|
}
|
|
|
|
public static void OpenLibs(IntPtr L)
|
|
{
|
|
AddLuaLoader(L);
|
|
LuaDLL.tolua_atpanic(L, Panic);
|
|
LuaDLL.tolua_pushcfunction(L, Print);
|
|
LuaDLL.lua_setglobal(L, "print");
|
|
LuaDLL.tolua_pushcfunction(L, DoFile);
|
|
LuaDLL.lua_setglobal(L, "dofile");
|
|
LuaDLL.tolua_pushcfunction(L, LoadFile);
|
|
LuaDLL.lua_setglobal(L, "loadfile");
|
|
|
|
LuaDLL.lua_getglobal(L, "tolua");
|
|
|
|
LuaDLL.lua_pushstring(L, "isnull");
|
|
LuaDLL.lua_pushcfunction(L, IsNull);
|
|
LuaDLL.lua_rawset(L, -3);
|
|
|
|
LuaDLL.lua_pushstring(L, "typeof");
|
|
LuaDLL.lua_pushcfunction(L, GetClassType);
|
|
LuaDLL.lua_rawset(L, -3);
|
|
|
|
LuaDLL.lua_pushstring(L, "tolstring");
|
|
LuaDLL.tolua_pushcfunction(L, BufferToString);
|
|
LuaDLL.lua_rawset(L, -3);
|
|
|
|
LuaDLL.lua_pushstring(L, "toarray");
|
|
LuaDLL.tolua_pushcfunction(L, TableToArray);
|
|
LuaDLL.lua_rawset(L, -3);
|
|
|
|
//手动模拟gc
|
|
//LuaDLL.lua_pushstring(L, "collect");
|
|
//LuaDLL.lua_pushcfunction(L, Collect);
|
|
//LuaDLL.lua_rawset(L, -3);
|
|
|
|
int meta = LuaStatic.GetMetaReference(L, typeof(NullObject));
|
|
LuaDLL.lua_pushstring(L, "null");
|
|
LuaDLL.tolua_pushnewudata(L, meta, 1);
|
|
LuaDLL.lua_rawset(L, -3);
|
|
LuaDLL.lua_pop(L, 1);
|
|
|
|
LuaDLL.tolua_pushudata(L, 1);
|
|
LuaDLL.lua_setfield(L, LuaIndexes.LUA_GLOBALSINDEX, "null");
|
|
|
|
#if UNITY_EDITOR
|
|
GetToLuaInstanceID();
|
|
GetConsoleWindowListView();
|
|
#endif
|
|
}
|
|
|
|
/*--------------------------------对于tolua扩展函数------------------------------------------*/
|
|
#region TOLUA_EXTEND_FUNCTIONS
|
|
static void AddLuaLoader(IntPtr L)
|
|
{
|
|
LuaDLL.lua_getglobal(L, "package");
|
|
LuaDLL.lua_getfield(L, -1, "loaders");
|
|
LuaDLL.tolua_pushcfunction(L, Loader);
|
|
|
|
for (int i = LuaDLL.lua_objlen(L, -2) + 1; i > 2; i--)
|
|
{
|
|
LuaDLL.lua_rawgeti(L, -2, i - 1);
|
|
LuaDLL.lua_rawseti(L, -3, i);
|
|
}
|
|
|
|
LuaDLL.lua_rawseti(L, -2, 2);
|
|
LuaDLL.lua_pop(L, 2);
|
|
}
|
|
|
|
[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
|
|
static int Panic(IntPtr L)
|
|
{
|
|
string reason = String.Format("PANIC: unprotected error in call to Lua API ({0})", LuaDLL.lua_tostring(L, -1));
|
|
throw new LuaException(reason);
|
|
}
|
|
|
|
[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
|
|
static int Print(IntPtr L)
|
|
{
|
|
try
|
|
{
|
|
int n = LuaDLL.lua_gettop(L);
|
|
|
|
using (CString.Block())
|
|
{
|
|
CString sb = CString.Alloc(256);
|
|
#if UNITY_EDITOR
|
|
int line = LuaDLL.tolua_where(L, 1);
|
|
string filename = LuaDLL.lua_tostring(L, -1);
|
|
LuaDLL.lua_settop(L, n);
|
|
int offset = filename[0] == '@' ? 1 : 0;
|
|
|
|
if (!filename.Contains("."))
|
|
{
|
|
sb.Append('[').Append(filename, offset, filename.Length - offset).Append(".lua:").Append(line).Append("]:");
|
|
}
|
|
else
|
|
{
|
|
sb.Append('[').Append(filename, offset, filename.Length - offset).Append(':').Append(line).Append("]:");
|
|
}
|
|
#endif
|
|
|
|
for (int i = 1; i <= n; i++)
|
|
{
|
|
if (i > 1) sb.Append(" ");
|
|
|
|
if (LuaDLL.lua_isstring(L, i) == 1)
|
|
{
|
|
sb.Append(LuaDLL.lua_tostring(L, i));
|
|
}
|
|
else if (LuaDLL.lua_isnil(L, i))
|
|
{
|
|
sb.Append("nil");
|
|
}
|
|
else if (LuaDLL.lua_isboolean(L, i))
|
|
{
|
|
sb.Append(LuaDLL.lua_toboolean(L, i) ? "true" : "false");
|
|
}
|
|
else
|
|
{
|
|
IntPtr p = LuaDLL.lua_topointer(L, i);
|
|
|
|
if (p == IntPtr.Zero)
|
|
{
|
|
sb.Append("nil");
|
|
}
|
|
else
|
|
{
|
|
sb.Append(LuaDLL.luaL_typename(L, i)).Append(":0x").Append(p.ToString("X"));
|
|
}
|
|
}
|
|
}
|
|
|
|
Debugger.Log(sb.ToString()); //200行与_line一致
|
|
}
|
|
return 0;
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
return LuaDLL.toluaL_exception(L, e);
|
|
}
|
|
}
|
|
|
|
[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
|
|
static int Loader(IntPtr L)
|
|
{
|
|
try
|
|
{
|
|
string fileName = LuaDLL.lua_tostring(L, 1);
|
|
fileName = fileName.Replace(".", "/");
|
|
byte[] buffer = LuaFileUtils.Instance.ReadFile(fileName);
|
|
|
|
if (buffer == null)
|
|
{
|
|
string error = LuaFileUtils.Instance.FindFileError(fileName);
|
|
LuaDLL.lua_pushstring(L, error);
|
|
return 1;
|
|
}
|
|
|
|
if (LuaConst.openLuaDebugger)
|
|
{
|
|
fileName = LuaFileUtils.Instance.FindFile(fileName);
|
|
}
|
|
|
|
if (LuaDLL.luaL_loadbuffer(L, buffer, buffer.Length, "@"+ fileName) != 0)
|
|
{
|
|
string err = LuaDLL.lua_tostring(L, -1);
|
|
throw new LuaException(err, LuaException.GetLastError());
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
return LuaDLL.toluaL_exception(L, e);
|
|
}
|
|
}
|
|
|
|
[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
|
|
public static int DoFile(IntPtr L)
|
|
{
|
|
try
|
|
{
|
|
string fileName = LuaDLL.lua_tostring(L, 1);
|
|
int n = LuaDLL.lua_gettop(L);
|
|
byte[] buffer = LuaFileUtils.Instance.ReadFile(fileName);
|
|
|
|
if (buffer == null)
|
|
{
|
|
string error = string.Format("cannot open {0}: No such file or directory", fileName);
|
|
error += LuaFileUtils.Instance.FindFileError(fileName);
|
|
throw new LuaException(error);
|
|
}
|
|
|
|
if (LuaDLL.luaL_loadbuffer(L, buffer, buffer.Length, fileName) == 0)
|
|
{
|
|
if (LuaDLL.lua_pcall(L, 0, LuaDLL.LUA_MULTRET, 0) != 0)
|
|
{
|
|
string error = LuaDLL.lua_tostring(L, -1);
|
|
throw new LuaException(error, LuaException.GetLastError());
|
|
}
|
|
}
|
|
else
|
|
{
|
|
string err = LuaDLL.lua_tostring(L, -1);
|
|
throw new LuaException(err, LuaException.GetLastError());
|
|
}
|
|
|
|
return LuaDLL.lua_gettop(L) - n;
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
return LuaDLL.toluaL_exception(L, e);
|
|
}
|
|
}
|
|
|
|
[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
|
|
public static int LoadFile(IntPtr L)
|
|
{
|
|
try
|
|
{
|
|
string fileName = LuaDLL.lua_tostring(L, 1);
|
|
byte[] buffer = LuaFileUtils.Instance.ReadFile(fileName);
|
|
|
|
if (buffer == null)
|
|
{
|
|
string error = string.Format("cannot open {0}: No such file or directory", fileName);
|
|
error += LuaFileUtils.Instance.FindFileError(fileName);
|
|
throw new LuaException(error);
|
|
}
|
|
|
|
if (LuaDLL.luaL_loadbuffer(L, buffer, buffer.Length, fileName) == 0)
|
|
{
|
|
return 1;
|
|
}
|
|
|
|
LuaDLL.lua_pushnil(L);
|
|
LuaDLL.lua_insert(L, -2); /* put before error message */
|
|
return 2;
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
return LuaDLL.toluaL_exception(L, e);
|
|
}
|
|
}
|
|
|
|
|
|
[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
|
|
static int IsNull(IntPtr L)
|
|
{
|
|
LuaTypes t = LuaDLL.lua_type(L, 1);
|
|
|
|
if (t == LuaTypes.LUA_TNIL)
|
|
{
|
|
LuaDLL.lua_pushboolean(L, true);
|
|
}
|
|
else
|
|
{
|
|
object o = ToLua.ToObject(L, -1);
|
|
|
|
if (o == null || o.Equals(null))
|
|
{
|
|
LuaDLL.lua_pushboolean(L, true);
|
|
}
|
|
else
|
|
{
|
|
LuaDLL.lua_pushboolean(L, false);
|
|
}
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
|
|
static int BufferToString(IntPtr L)
|
|
{
|
|
try
|
|
{
|
|
object o = CheckObject(L, 1);
|
|
|
|
if (o is byte[])
|
|
{
|
|
byte[] buff = (byte[])o;
|
|
LuaDLL.lua_pushlstring(L, buff, buff.Length);
|
|
}
|
|
else if (o is char[])
|
|
{
|
|
byte[] buff = System.Text.Encoding.UTF8.GetBytes((char[])o);
|
|
LuaDLL.lua_pushlstring(L, buff, buff.Length);
|
|
}
|
|
else if (o is string)
|
|
{
|
|
LuaDLL.lua_pushstring(L, (string)o);
|
|
}
|
|
else
|
|
{
|
|
LuaDLL.luaL_typerror(L, 1, "byte[] or char[]");
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
return LuaDLL.toluaL_exception(L, e);
|
|
}
|
|
}
|
|
|
|
[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
|
|
static int GetClassType(IntPtr L)
|
|
{
|
|
int reference = LuaDLL.tolua_getmetatableref(L, 1);
|
|
|
|
if (reference > 0)
|
|
{
|
|
Type t = LuaStatic.GetClassType(L, reference);
|
|
Push(L, t);
|
|
}
|
|
else
|
|
{
|
|
int ret = LuaDLL.tolua_getvaluetype(L, -1);
|
|
|
|
if (ret != LuaValueType.None)
|
|
{
|
|
Type t = TypeChecker.LuaValueTypeMap[ret];
|
|
Push(L, t);
|
|
}
|
|
else
|
|
{
|
|
Debugger.LogError("type not register to lua");
|
|
LuaDLL.lua_pushnil(L);
|
|
}
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
|
|
static int TableToArray(IntPtr L)
|
|
{
|
|
try
|
|
{
|
|
object[] objs = ToLua.CheckObjectArray(L, 1);
|
|
Type t = ToLua.CheckMonoType(L, 2);
|
|
Array ret = System.Array.CreateInstance(t, objs.Length);
|
|
|
|
for (int i = 0; i < objs.Length; i++)
|
|
{
|
|
ret.SetValue(objs[i], i);
|
|
}
|
|
|
|
ToLua.Push(L, ret);
|
|
return 1;
|
|
}
|
|
catch(LuaException e)
|
|
{
|
|
return LuaDLL.toluaL_exception(L, e);
|
|
}
|
|
}
|
|
|
|
[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
|
|
public static int op_ToString(IntPtr L)
|
|
{
|
|
object obj = ToLua.ToObject(L, 1);
|
|
|
|
if (obj != null)
|
|
{
|
|
LuaDLL.lua_pushstring(L, obj.ToString());
|
|
}
|
|
else
|
|
{
|
|
LuaDLL.lua_pushnil(L);
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
#if UNITY_EDITOR
|
|
private static bool GetConsoleWindowListView()
|
|
{
|
|
if (logListView == null)
|
|
{
|
|
Assembly unityEditorAssembly = Assembly.GetAssembly(typeof(EditorWindow));
|
|
Type consoleWindowType = unityEditorAssembly.GetType("UnityEditor.ConsoleWindow");
|
|
FieldInfo fieldInfo = consoleWindowType.GetField("ms_ConsoleWindow", BindingFlags.Static | BindingFlags.NonPublic);
|
|
consoleWindow = fieldInfo.GetValue(null);
|
|
|
|
if (consoleWindow == null)
|
|
{
|
|
logListView = null;
|
|
return false;
|
|
}
|
|
|
|
FieldInfo listViewFieldInfo = consoleWindowType.GetField("m_ListView", BindingFlags.Instance | BindingFlags.NonPublic);
|
|
logListView = listViewFieldInfo.GetValue(consoleWindow);
|
|
logListViewCurrentRow = listViewFieldInfo.FieldType.GetField("row", BindingFlags.Instance | BindingFlags.Public);
|
|
#if UNITY_2017_1_OR_NEWER
|
|
Type logEntriesType = unityEditorAssembly.GetType("UnityEditor.LogEntries");
|
|
LogEntriesGetEntry = logEntriesType.GetMethod("GetEntryInternal", BindingFlags.Static | BindingFlags.Public);
|
|
Type logEntryType = unityEditorAssembly.GetType("UnityEditor.LogEntry");
|
|
#else
|
|
Type logEntriesType = unityEditorAssembly.GetType("UnityEditorInternal.LogEntries");
|
|
LogEntriesGetEntry = logEntriesType.GetMethod("GetEntryInternal", BindingFlags.Static | BindingFlags.Public);
|
|
Type logEntryType = unityEditorAssembly.GetType("UnityEditorInternal.LogEntry");
|
|
#endif
|
|
logEntry = Activator.CreateInstance(logEntryType);
|
|
logEntryCondition = logEntryType.GetField("condition", BindingFlags.Instance | BindingFlags.Public);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
private static string GetListViewRowCount(ref int line)
|
|
{
|
|
int row = (int)logListViewCurrentRow.GetValue(logListView);
|
|
LogEntriesGetEntry.Invoke(null, new object[] { row, logEntry });
|
|
string condition = logEntryCondition.GetValue(logEntry) as string;
|
|
condition = condition.Substring(0, condition.IndexOf('\n'));
|
|
int index = condition.IndexOf(".lua:");
|
|
|
|
if (index >= 0)
|
|
{
|
|
int start = condition.IndexOf("[");
|
|
int end = condition.IndexOf("]:");
|
|
string _line = condition.Substring(index + 5, end - index - 4);
|
|
Int32.TryParse(_line, out line);
|
|
return condition.Substring(start + 1, index + 3 - start);
|
|
}
|
|
|
|
index = condition.IndexOf(".cs:");
|
|
|
|
if (index >= 0)
|
|
{
|
|
int start = condition.IndexOf("[");
|
|
int end = condition.IndexOf("]:");
|
|
string _line = condition.Substring(index + 5, end - index - 4);
|
|
Int32.TryParse(_line, out line);
|
|
return condition.Substring(start + 1, index + 2 - start);
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
static void GetToLuaInstanceID()
|
|
{
|
|
if (_instanceID == -1)
|
|
{
|
|
int start = LuaConst.toluaDir.IndexOf("Assets");
|
|
int end = LuaConst.toluaDir.LastIndexOf("/Lua");
|
|
string dir = LuaConst.toluaDir.Substring(start, end - start);
|
|
dir += "/Core/ToLua.cs";
|
|
_instanceID = AssetDatabase.LoadAssetAtPath(dir, typeof(MonoScript)).GetInstanceID();//"Assets/ToLua/Core/ToLua.cs"
|
|
}
|
|
}
|
|
|
|
[OnOpenAssetAttribute(0)]
|
|
public static bool OnOpenAsset(int instanceID, int line)
|
|
{
|
|
GetToLuaInstanceID();
|
|
|
|
if (!GetConsoleWindowListView() || (object)EditorWindow.focusedWindow != consoleWindow)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (instanceID == _instanceID && line == _line)
|
|
{
|
|
string fileName = GetListViewRowCount(ref line);
|
|
|
|
if (fileName == null)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (fileName.EndsWith(".cs"))
|
|
{
|
|
string filter = fileName.Substring(0, fileName.Length - 3);
|
|
filter += " t:MonoScript";
|
|
string[] searchPaths = AssetDatabase.FindAssets(filter);
|
|
|
|
for (int i = 0; i < searchPaths.Length; i++)
|
|
{
|
|
string path = AssetDatabase.GUIDToAssetPath(searchPaths[i]);
|
|
|
|
if (path.EndsWith(fileName))
|
|
{
|
|
UnityEngine.Object obj = AssetDatabase.LoadAssetAtPath(path, typeof(MonoScript));
|
|
AssetDatabase.OpenAsset(obj, line);
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
string filter = fileName.Substring(0, fileName.Length - 4);
|
|
int index = filter.IndexOf("/");
|
|
if (index > 0)
|
|
{
|
|
filter = filter.Substring(index + 1);
|
|
}
|
|
string[] searchPaths = AssetDatabase.FindAssets(filter);
|
|
|
|
for (int i = 0; i < searchPaths.Length; i++)
|
|
{
|
|
string path = AssetDatabase.GUIDToAssetPath(searchPaths[i]);
|
|
|
|
if (path.EndsWith(fileName) || path.EndsWith(fileName + ".bytes"))
|
|
{
|
|
UnityEngine.Object obj = AssetDatabase.LoadMainAssetAtPath(path);
|
|
AssetDatabase.OpenAsset(obj, line);
|
|
return true;
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
#endif
|
|
#endregion
|
|
/*-------------------------------------------------------------------------------------------*/
|
|
|
|
public static string ToString(IntPtr L, int stackPos)
|
|
{
|
|
LuaTypes luaType = LuaDLL.lua_type(L, stackPos);
|
|
|
|
switch (luaType)
|
|
{
|
|
case LuaTypes.LUA_TSTRING:
|
|
return LuaDLL.lua_tostring(L, stackPos);
|
|
case LuaTypes.LUA_TUSERDATA:
|
|
return (string)ToObject(L, stackPos);
|
|
default:
|
|
return null;
|
|
}
|
|
}
|
|
|
|
public static object ToObject(IntPtr L, int stackPos)
|
|
{
|
|
int udata = LuaDLL.tolua_rawnetobj(L, stackPos);
|
|
|
|
if (udata != -1)
|
|
{
|
|
ObjectTranslator translator = ObjectTranslator.Get(L);
|
|
return translator.GetObject(udata);
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
public static LuaFunction ToLuaFunction(IntPtr L, int stackPos)
|
|
{
|
|
LuaTypes type = LuaDLL.lua_type(L, stackPos);
|
|
|
|
if (type == LuaTypes.LUA_TNIL)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
stackPos = LuaDLL.abs_index(L, stackPos);
|
|
LuaDLL.lua_pushvalue(L, stackPos);
|
|
int reference = LuaDLL.toluaL_ref(L);
|
|
return LuaStatic.GetFunction(L, reference);
|
|
}
|
|
|
|
public static LuaTable ToLuaTable(IntPtr L, int stackPos)
|
|
{
|
|
LuaTypes type = LuaDLL.lua_type(L, stackPos);
|
|
|
|
if (type == LuaTypes.LUA_TNIL)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
stackPos = LuaDLL.abs_index(L, stackPos);
|
|
LuaDLL.lua_pushvalue(L, stackPos);
|
|
int reference = LuaDLL.toluaL_ref(L);
|
|
return LuaStatic.GetTable(L, reference);
|
|
}
|
|
|
|
public static LuaThread ToLuaThread(IntPtr L, int stackPos)
|
|
{
|
|
LuaTypes type = LuaDLL.lua_type(L, stackPos);
|
|
|
|
if (type == LuaTypes.LUA_TNIL)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
stackPos = LuaDLL.abs_index(L, stackPos);
|
|
LuaDLL.lua_pushvalue(L, stackPos);
|
|
int reference = LuaDLL.toluaL_ref(L);
|
|
return LuaStatic.GetLuaThread(L, reference);
|
|
}
|
|
|
|
public static Vector3 ToVector3(IntPtr L, int stackPos)
|
|
{
|
|
float x = 0, y = 0, z = 0;
|
|
LuaDLL.tolua_getvec3(L, stackPos, out x, out y, out z);
|
|
return new Vector3(x, y, z);
|
|
}
|
|
|
|
public static Vector4 ToVector4(IntPtr L, int stackPos)
|
|
{
|
|
float x, y, z, w;
|
|
LuaDLL.tolua_getvec4(L, stackPos, out x, out y, out z, out w);
|
|
return new Vector4(x, y, z, w);
|
|
}
|
|
|
|
public static Vector2 ToVector2(IntPtr L, int stackPos)
|
|
{
|
|
float x, y;
|
|
LuaDLL.tolua_getvec2(L, stackPos, out x, out y);
|
|
return new Vector2(x, y);
|
|
}
|
|
|
|
public static Quaternion ToQuaternion(IntPtr L, int stackPos)
|
|
{
|
|
float x, y, z, w;
|
|
LuaDLL.tolua_getquat(L, stackPos, out x, out y, out z, out w);
|
|
return new Quaternion(x, y, z, w);
|
|
}
|
|
|
|
public static Color ToColor(IntPtr L, int stackPos)
|
|
{
|
|
float r, g, b, a;
|
|
LuaDLL.tolua_getclr(L, stackPos, out r, out g, out b, out a);
|
|
return new Color(r, g, b, a);
|
|
}
|
|
|
|
public static Ray ToRay(IntPtr L, int stackPos)
|
|
{
|
|
int top = LuaDLL.lua_gettop(L);
|
|
LuaStatic.GetUnpackRayRef(L);
|
|
stackPos = LuaDLL.abs_index(L, stackPos);
|
|
LuaDLL.lua_pushvalue(L, stackPos);
|
|
|
|
if (LuaDLL.lua_pcall(L, 1, 6, 0) == 0)
|
|
{
|
|
float ox = (float)LuaDLL.lua_tonumber(L, top + 1);
|
|
float oy = (float)LuaDLL.lua_tonumber(L, top + 2);
|
|
float oz = (float)LuaDLL.lua_tonumber(L, top + 3);
|
|
float dx = (float)LuaDLL.lua_tonumber(L, top + 4);
|
|
float dy = (float)LuaDLL.lua_tonumber(L, top + 5);
|
|
float dz = (float)LuaDLL.lua_tonumber(L, top + 6);
|
|
LuaDLL.lua_settop(L, top);
|
|
return new Ray(new Vector3(ox, oy, oz), new Vector3(dx, dy, dz));
|
|
}
|
|
else
|
|
{
|
|
string error = LuaDLL.lua_tostring(L, -1);
|
|
LuaDLL.lua_settop(L, top);
|
|
throw new LuaException(error);
|
|
}
|
|
}
|
|
|
|
public static Bounds ToBounds(IntPtr L, int stackPos)
|
|
{
|
|
int top = LuaDLL.lua_gettop(L);
|
|
LuaStatic.GetUnpackBounds(L);
|
|
stackPos = LuaDLL.abs_index(L, stackPos);
|
|
LuaDLL.lua_pushvalue(L, stackPos);
|
|
|
|
if (LuaDLL.lua_pcall(L, 1, 2, 0) == 0)
|
|
{
|
|
Vector3 center = ToVector3(L, top + 1);
|
|
Vector3 size = ToVector3(L, top + 2);
|
|
LuaDLL.lua_settop(L, top);
|
|
return new Bounds(center, size);
|
|
}
|
|
else
|
|
{
|
|
string error = LuaDLL.lua_tostring(L, -1);
|
|
LuaDLL.lua_settop(L, top);
|
|
throw new LuaException(error);
|
|
}
|
|
}
|
|
|
|
public static LayerMask ToLayerMask(IntPtr L, int stackPos)
|
|
{
|
|
return LuaDLL.tolua_getlayermask(L, stackPos);
|
|
}
|
|
|
|
public static object ToVarObject(IntPtr L, int stackPos)
|
|
{
|
|
LuaTypes type = LuaDLL.lua_type(L, stackPos);
|
|
|
|
switch (type)
|
|
{
|
|
case LuaTypes.LUA_TNUMBER:
|
|
return LuaDLL.lua_tonumber(L, stackPos);
|
|
case LuaTypes.LUA_TSTRING:
|
|
return LuaDLL.lua_tostring(L, stackPos);
|
|
case LuaTypes.LUA_TUSERDATA:
|
|
switch(LuaDLL.tolua_getvaluetype(L, stackPos))
|
|
{
|
|
case LuaValueType.Int64:
|
|
return LuaDLL.tolua_toint64(L, stackPos);
|
|
case LuaValueType.UInt64:
|
|
return LuaDLL.tolua_touint64(L, stackPos);
|
|
default:
|
|
return ToObject(L, stackPos);
|
|
}
|
|
case LuaTypes.LUA_TBOOLEAN:
|
|
return LuaDLL.lua_toboolean(L, stackPos);
|
|
case LuaTypes.LUA_TFUNCTION:
|
|
return ToLuaFunction(L, stackPos);
|
|
case LuaTypes.LUA_TTABLE:
|
|
return ToVarTable(L, stackPos);
|
|
case LuaTypes.LUA_TNIL:
|
|
return null;
|
|
case LuaTypes.LUA_TLIGHTUSERDATA:
|
|
return LuaDLL.lua_touserdata(L, stackPos);
|
|
case LuaTypes.LUA_TTHREAD:
|
|
return ToLuaThread(L, stackPos);
|
|
default:
|
|
return null;
|
|
}
|
|
}
|
|
|
|
//for Generic Array and List, 转换double为指定type在存入object
|
|
public static object ToVarObject(IntPtr L, int stackPos, Type t)
|
|
{
|
|
LuaTypes type = LuaDLL.lua_type(L, stackPos);
|
|
|
|
if (type == LuaTypes.LUA_TNUMBER)
|
|
{
|
|
object o = LuaDLL.lua_tonumber(L, stackPos);
|
|
o = Convert.ChangeType(o, t);
|
|
return o;
|
|
}
|
|
|
|
return ToVarObject(L, stackPos);
|
|
}
|
|
|
|
public static object ToVarTable(IntPtr L, int stackPos)
|
|
{
|
|
stackPos = LuaDLL.abs_index(L, stackPos);
|
|
int ret = LuaDLL.tolua_getvaluetype(L, stackPos);
|
|
LuaTableToVar _ToObject = ToVarMap[ret];
|
|
|
|
if (_ToObject != null)
|
|
{
|
|
return _ToObject(L, stackPos);
|
|
}
|
|
else
|
|
{
|
|
LuaDLL.lua_pushvalue(L, stackPos);
|
|
int reference = LuaDLL.toluaL_ref(L);
|
|
return LuaStatic.GetTable(L, reference);
|
|
}
|
|
}
|
|
|
|
public static Nullable<T> ToNullable<T>(IntPtr L, int stackPos) where T : struct
|
|
{
|
|
if (LuaDLL.lua_type(L, stackPos) == LuaTypes.LUA_TNIL)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
return StackTraits<T>.To(L, stackPos);
|
|
}
|
|
|
|
static object ToObjectVec3(IntPtr L, int stackPos)
|
|
{
|
|
return ToVector3(L, stackPos);
|
|
}
|
|
|
|
static object ToObjectQuat(IntPtr L, int stackPos)
|
|
{
|
|
return ToQuaternion(L, stackPos);
|
|
}
|
|
|
|
static object ToObjectColor(IntPtr L, int stackPos)
|
|
{
|
|
return ToColor(L, stackPos);
|
|
}
|
|
|
|
static object ToObjectVec4(IntPtr L, int stackPos)
|
|
{
|
|
return ToVector4(L, stackPos);
|
|
}
|
|
|
|
static object ToObjectVec2(IntPtr L, int stackPos)
|
|
{
|
|
return ToVector2(L, stackPos);
|
|
}
|
|
|
|
static object ToObjectRay(IntPtr L, int stackPos)
|
|
{
|
|
return ToRay(L, stackPos);
|
|
}
|
|
|
|
static object ToObjectLayerMask(IntPtr L, int stackPos)
|
|
{
|
|
return ToLayerMask(L, stackPos);
|
|
}
|
|
|
|
static object ToObjectBounds(IntPtr L, int stackPos)
|
|
{
|
|
return ToBounds(L, stackPos);
|
|
}
|
|
|
|
public static LuaFunction CheckLuaFunction(IntPtr L, int stackPos)
|
|
{
|
|
LuaTypes luaType = LuaDLL.lua_type(L, stackPos);
|
|
|
|
switch (luaType)
|
|
{
|
|
case LuaTypes.LUA_TNIL:
|
|
return null;
|
|
case LuaTypes.LUA_TFUNCTION:
|
|
stackPos = LuaDLL.abs_index(L, stackPos);
|
|
LuaDLL.lua_pushvalue(L, stackPos);
|
|
int reference = LuaDLL.toluaL_ref(L);
|
|
return LuaStatic.GetFunction(L, reference);
|
|
default:
|
|
LuaDLL.luaL_typerror(L, stackPos, "function");
|
|
return null;
|
|
}
|
|
}
|
|
|
|
public static LuaTable CheckLuaTable(IntPtr L, int stackPos)
|
|
{
|
|
LuaTypes luaType = LuaDLL.lua_type(L, stackPos);
|
|
|
|
switch (luaType)
|
|
{
|
|
case LuaTypes.LUA_TNIL:
|
|
return null;
|
|
case LuaTypes.LUA_TTABLE:
|
|
stackPos = LuaDLL.abs_index(L, stackPos);
|
|
LuaDLL.lua_pushvalue(L, stackPos);
|
|
int reference = LuaDLL.toluaL_ref(L);
|
|
return LuaStatic.GetTable(L, reference);
|
|
default:
|
|
LuaDLL.luaL_typerror(L, stackPos, "table");
|
|
return null;
|
|
}
|
|
}
|
|
|
|
public static LuaThread CheckLuaThread(IntPtr L, int stackPos)
|
|
{
|
|
LuaTypes luaType = LuaDLL.lua_type(L, stackPos);
|
|
|
|
switch (luaType)
|
|
{
|
|
case LuaTypes.LUA_TNIL:
|
|
return null;
|
|
case LuaTypes.LUA_TTHREAD:
|
|
stackPos = LuaDLL.abs_index(L, stackPos);
|
|
LuaDLL.lua_pushvalue(L, stackPos);
|
|
int reference = LuaDLL.toluaL_ref(L);
|
|
return LuaStatic.GetLuaThread(L, reference);
|
|
default:
|
|
LuaDLL.luaL_typerror(L, stackPos, "thread");
|
|
return null;
|
|
}
|
|
}
|
|
|
|
public static LuaBaseRef CheckLuaBaseRef(IntPtr L, int stackPos)
|
|
{
|
|
LuaTypes luaType = LuaDLL.lua_type(L, stackPos);
|
|
|
|
switch (luaType)
|
|
{
|
|
case LuaTypes.LUA_TNIL:
|
|
return null;
|
|
case LuaTypes.LUA_TFUNCTION:
|
|
stackPos = LuaDLL.abs_index(L, stackPos);
|
|
LuaDLL.lua_pushvalue(L, stackPos);
|
|
int ref1 = LuaDLL.toluaL_ref(L);
|
|
return LuaStatic.GetFunction(L, ref1);
|
|
case LuaTypes.LUA_TTABLE:
|
|
stackPos = LuaDLL.abs_index(L, stackPos);
|
|
LuaDLL.lua_pushvalue(L, stackPos);
|
|
int ref2 = LuaDLL.toluaL_ref(L);
|
|
return LuaStatic.GetTable(L, ref2);
|
|
case LuaTypes.LUA_TTHREAD:
|
|
stackPos = LuaDLL.abs_index(L, stackPos);
|
|
LuaDLL.lua_pushvalue(L, stackPos);
|
|
int ref3 = LuaDLL.toluaL_ref(L);
|
|
return LuaStatic.GetLuaThread(L, ref3);
|
|
default:
|
|
LuaDLL.luaL_typerror(L, stackPos, "function or table or thread");
|
|
return null;
|
|
}
|
|
}
|
|
|
|
public static string CheckString(IntPtr L, int stackPos)
|
|
{
|
|
LuaTypes luaType = LuaDLL.lua_type(L, stackPos);
|
|
|
|
switch (luaType)
|
|
{
|
|
case LuaTypes.LUA_TNIL:
|
|
return null;
|
|
case LuaTypes.LUA_TNUMBER:
|
|
return LuaDLL.lua_tostring(L, stackPos);
|
|
case LuaTypes.LUA_TSTRING:
|
|
return LuaDLL.lua_tostring(L, stackPos);
|
|
case LuaTypes.LUA_TUSERDATA:
|
|
int udata = LuaDLL.tolua_rawnetobj(L, stackPos);
|
|
|
|
if (udata != -1)
|
|
{
|
|
ObjectTranslator translator = ObjectTranslator.Get(L);
|
|
object obj = translator.GetObject(udata);
|
|
|
|
if (obj != null)
|
|
{
|
|
if (obj is string)
|
|
{
|
|
return (string)obj;
|
|
}
|
|
|
|
LuaDLL.luaL_argerror(L, stackPos, string.Format("string expected, got {0}", obj.GetType().FullName));
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
LuaDLL.luaL_typerror(L, stackPos, "string");
|
|
return null;
|
|
}
|
|
|
|
public static IntPtr CheckIntPtr(IntPtr L, int stackPos)
|
|
{
|
|
LuaTypes luaType = LuaDLL.lua_type(L, stackPos);
|
|
|
|
switch (luaType)
|
|
{
|
|
case LuaTypes.LUA_TNIL:
|
|
return IntPtr.Zero;
|
|
case LuaTypes.LUA_TLIGHTUSERDATA:
|
|
return LuaDLL.lua_touserdata(L, stackPos);
|
|
default:
|
|
LuaDLL.luaL_typerror(L, stackPos, "IntPtr");
|
|
return IntPtr.Zero;
|
|
}
|
|
}
|
|
|
|
static public Type CheckMonoType(IntPtr L, int stackPos)
|
|
{
|
|
int udata = LuaDLL.tolua_rawnetobj(L, stackPos);
|
|
|
|
if (udata != -1)
|
|
{
|
|
ObjectTranslator translator = ObjectTranslator.Get(L);
|
|
object obj = translator.GetObject(udata);
|
|
|
|
if (obj != null)
|
|
{
|
|
if (obj is Type)
|
|
{
|
|
return (Type)obj;
|
|
}
|
|
|
|
LuaDLL.luaL_argerror(L, stackPos, string.Format("Type expected, got {0}", obj.GetType().FullName));
|
|
}
|
|
|
|
return null;
|
|
}
|
|
else if (LuaDLL.lua_isnil(L, stackPos))
|
|
{
|
|
return null;
|
|
}
|
|
|
|
LuaDLL.luaL_typerror(L, stackPos, "Type");
|
|
return null;
|
|
}
|
|
|
|
public static IEnumerator CheckIter(IntPtr L, int stackPos)
|
|
{
|
|
int udata = LuaDLL.tolua_rawnetobj(L, stackPos);
|
|
|
|
if (udata != -1)
|
|
{
|
|
ObjectTranslator translator = ObjectTranslator.Get(L);
|
|
object obj = translator.GetObject(udata);
|
|
|
|
if (obj != null)
|
|
{
|
|
if (obj is IEnumerator)
|
|
{
|
|
return (IEnumerator)obj;
|
|
}
|
|
|
|
LuaDLL.luaL_argerror(L, stackPos, string.Format("Type expected, got {0}", obj.GetType().FullName));
|
|
}
|
|
|
|
return null;
|
|
}
|
|
else if (LuaDLL.lua_isnil(L, stackPos))
|
|
{
|
|
return null;
|
|
}
|
|
|
|
LuaDLL.luaL_typerror(L, stackPos, "Type");
|
|
return null;
|
|
}
|
|
|
|
public static object CheckObject(IntPtr L, int stackPos)
|
|
{
|
|
int udata = LuaDLL.tolua_rawnetobj(L, stackPos);
|
|
|
|
if (udata != -1)
|
|
{
|
|
ObjectTranslator translator = ObjectTranslator.Get(L);
|
|
return translator.GetObject(udata);
|
|
}
|
|
else if (LuaDLL.lua_isnil(L, stackPos))
|
|
{
|
|
return null;
|
|
}
|
|
|
|
LuaDLL.luaL_typerror(L, stackPos, "object");
|
|
return null;
|
|
}
|
|
|
|
public static object CheckObject(IntPtr L, int stackPos, Type type)
|
|
{
|
|
int udata = LuaDLL.tolua_rawnetobj(L, stackPos);
|
|
|
|
if (udata != -1)
|
|
{
|
|
ObjectTranslator translator = ObjectTranslator.Get(L);
|
|
object obj = translator.GetObject(udata);
|
|
|
|
if (obj != null)
|
|
{
|
|
Type objType = obj.GetType();
|
|
|
|
if (type == objType || type.IsAssignableFrom(objType))
|
|
{
|
|
return obj;
|
|
}
|
|
|
|
LuaDLL.luaL_argerror(L, stackPos, string.Format("{0} expected, got {1}", LuaMisc.GetTypeName(type), LuaMisc.GetTypeName(objType)));
|
|
}
|
|
|
|
return null;
|
|
}
|
|
else if (type.IsEnum && LuaDLL.lua_isstring(L, stackPos) != 0)
|
|
{
|
|
return Enum.Parse(type, LuaDLL.lua_tostring(L, stackPos));
|
|
}
|
|
else if (LuaDLL.lua_isnil(L, stackPos))
|
|
{
|
|
return null;
|
|
}
|
|
|
|
LuaDLL.luaL_typerror(L, stackPos, LuaMisc.GetTypeName(type));
|
|
return null;
|
|
}
|
|
|
|
public static object CheckObject<T>(IntPtr L, int stackPos) where T : class
|
|
{
|
|
int udata = LuaDLL.tolua_rawnetobj(L, stackPos);
|
|
|
|
if (udata != -1)
|
|
{
|
|
ObjectTranslator translator = ObjectTranslator.Get(L);
|
|
object obj = translator.GetObject(udata);
|
|
|
|
if (obj != null)
|
|
{
|
|
if (obj is T)
|
|
{
|
|
return obj;
|
|
}
|
|
|
|
Type objType = obj.GetType();
|
|
LuaDLL.luaL_argerror(L, stackPos, string.Format("{0} expected, got {1}", TypeTraits<T>.GetTypeName(), objType.FullName));
|
|
}
|
|
|
|
return null;
|
|
}
|
|
else if (LuaDLL.lua_isnil(L, stackPos))
|
|
{
|
|
return null;
|
|
}
|
|
|
|
LuaDLL.luaL_typerror(L, stackPos, TypeTraits<T>.GetTypeName());
|
|
return null;
|
|
}
|
|
|
|
static public Vector3 CheckVector3(IntPtr L, int stackPos)
|
|
{
|
|
int type = LuaDLL.tolua_getvaluetype(L, stackPos);
|
|
|
|
if (type != LuaValueType.Vector3)
|
|
{
|
|
LuaDLL.luaL_typerror(L, stackPos, "Vector3", LuaValueTypeName.Get(type));
|
|
return Vector3.zero;
|
|
}
|
|
|
|
float x, y, z;
|
|
LuaDLL.tolua_getvec3(L, stackPos, out x, out y, out z);
|
|
return new Vector3(x, y, z);
|
|
}
|
|
|
|
static public Quaternion CheckQuaternion(IntPtr L, int stackPos)
|
|
{
|
|
int type = LuaDLL.tolua_getvaluetype(L, stackPos);
|
|
|
|
if (type != LuaValueType.Quaternion)
|
|
{
|
|
LuaDLL.luaL_typerror(L, stackPos, "Quaternion", LuaValueTypeName.Get(type));
|
|
return Quaternion.identity;
|
|
}
|
|
|
|
float x, y, z, w;
|
|
LuaDLL.tolua_getquat(L, stackPos, out x, out y, out z, out w);
|
|
return new Quaternion(x, y, z, w);
|
|
}
|
|
|
|
static public Vector2 CheckVector2(IntPtr L, int stackPos)
|
|
{
|
|
int type = LuaDLL.tolua_getvaluetype(L, stackPos);
|
|
|
|
if (type != LuaValueType.Vector2)
|
|
{
|
|
LuaDLL.luaL_typerror(L, stackPos, "Vector2", LuaValueTypeName.Get(type));
|
|
return Vector2.zero;
|
|
}
|
|
|
|
float x, y;
|
|
LuaDLL.tolua_getvec2(L, stackPos, out x, out y);
|
|
return new Vector2(x, y);
|
|
}
|
|
|
|
static public Vector4 CheckVector4(IntPtr L, int stackPos)
|
|
{
|
|
int type = LuaDLL.tolua_getvaluetype(L, stackPos);
|
|
|
|
if (type != LuaValueType.Vector4)
|
|
{
|
|
LuaDLL.luaL_typerror(L, stackPos, "Vector4", LuaValueTypeName.Get(type));
|
|
return Vector4.zero;
|
|
}
|
|
|
|
float x, y, z, w;
|
|
LuaDLL.tolua_getvec4(L, stackPos, out x, out y, out z, out w);
|
|
return new Vector4(x, y, z, w);
|
|
}
|
|
|
|
static public Color CheckColor(IntPtr L, int stackPos)
|
|
{
|
|
int type = LuaDLL.tolua_getvaluetype(L, stackPos);
|
|
|
|
if (type != LuaValueType.Color)
|
|
{
|
|
LuaDLL.luaL_typerror(L, stackPos, "Color", LuaValueTypeName.Get(type));
|
|
return Color.black;
|
|
}
|
|
|
|
float r, g, b, a;
|
|
LuaDLL.tolua_getclr(L, stackPos, out r, out g, out b, out a);
|
|
return new Color(r, g, b, a);
|
|
}
|
|
|
|
static public Ray CheckRay(IntPtr L, int stackPos)
|
|
{
|
|
int type = LuaDLL.tolua_getvaluetype(L, stackPos);
|
|
|
|
if (type != LuaValueType.Ray)
|
|
{
|
|
LuaDLL.luaL_typerror(L, stackPos, "Ray", LuaValueTypeName.Get(type));
|
|
return new Ray();
|
|
}
|
|
|
|
return ToRay(L, stackPos);
|
|
}
|
|
|
|
static public Bounds CheckBounds(IntPtr L, int stackPos)
|
|
{
|
|
int type = LuaDLL.tolua_getvaluetype(L, stackPos);
|
|
|
|
if (type != LuaValueType.Bounds)
|
|
{
|
|
LuaDLL.luaL_typerror(L, stackPos, "Bounds", LuaValueTypeName.Get(type));
|
|
return new Bounds();
|
|
}
|
|
|
|
return ToBounds(L, stackPos);
|
|
}
|
|
|
|
static public LayerMask CheckLayerMask(IntPtr L, int stackPos)
|
|
{
|
|
int type = LuaDLL.tolua_getvaluetype(L, stackPos);
|
|
|
|
if (type != LuaValueType.LayerMask)
|
|
{
|
|
LuaDLL.luaL_typerror(L, stackPos, "LayerMask", LuaValueTypeName.Get(type));
|
|
return 0;
|
|
}
|
|
|
|
return LuaDLL.tolua_getlayermask(L, stackPos);
|
|
}
|
|
|
|
public static T CheckValue<T>(IntPtr L, int stackPos) where T : struct
|
|
{
|
|
return StackTraits<T>.Check(L, stackPos);
|
|
}
|
|
|
|
public static Nullable<T> CheckNullable<T>(IntPtr L, int stackPos) where T : struct
|
|
{
|
|
if (LuaDLL.lua_type(L, stackPos) == LuaTypes.LUA_TNIL)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
return StackTraits<T>.Check(L, stackPos);
|
|
}
|
|
|
|
public static object CheckVarObject(IntPtr L, int stackPos, Type t)
|
|
{
|
|
bool beValue = TypeChecker.IsValueType(t);
|
|
LuaTypes luaType = LuaDLL.lua_type(L, stackPos);
|
|
|
|
if (!beValue && luaType == LuaTypes.LUA_TNIL)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
if (beValue)
|
|
{
|
|
if (TypeChecker.IsNullable(t))
|
|
{
|
|
if (luaType == LuaTypes.LUA_TNIL)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
Type[] ts = t.GetGenericArguments();
|
|
t = ts[0];
|
|
}
|
|
|
|
if (t == typeof(bool))
|
|
{
|
|
return LuaDLL.luaL_checkboolean(L, stackPos);
|
|
}
|
|
else if (t == typeof(long))
|
|
{
|
|
return LuaDLL.tolua_checkint64(L, stackPos);
|
|
}
|
|
else if (t == typeof(ulong))
|
|
{
|
|
return LuaDLL.tolua_checkuint64(L, stackPos);
|
|
}
|
|
else if (t.IsPrimitive)
|
|
{
|
|
double d = LuaDLL.luaL_checknumber(L, stackPos);
|
|
return Convert.ChangeType(d, t);
|
|
}
|
|
else if (t == typeof(LuaByteBuffer))
|
|
{
|
|
int len = 0;
|
|
IntPtr source = LuaDLL.tolua_tolstring(L, stackPos, out len);
|
|
return new LuaByteBuffer(source, len);
|
|
}
|
|
else if (t == typeof(Vector3))
|
|
{
|
|
return CheckVector3(L, stackPos);
|
|
}
|
|
else if (t == typeof(Quaternion))
|
|
{
|
|
return CheckQuaternion(L, stackPos);
|
|
}
|
|
else if (t == typeof(Vector2))
|
|
{
|
|
return CheckVector2(L, stackPos);
|
|
}
|
|
else if (t == typeof(Vector4))
|
|
{
|
|
return CheckVector4(L, stackPos);
|
|
}
|
|
else if (t == typeof(Color))
|
|
{
|
|
return CheckColor(L, stackPos);
|
|
}
|
|
else if (t == typeof(Ray))
|
|
{
|
|
return CheckRay(L, stackPos);
|
|
}
|
|
else if (t == typeof(Bounds))
|
|
{
|
|
return CheckBounds(L, stackPos);
|
|
}
|
|
else if (t == typeof(LayerMask))
|
|
{
|
|
return CheckLayerMask(L, stackPos);
|
|
}
|
|
else
|
|
{
|
|
if (luaType == LuaTypes.LUA_TTABLE)
|
|
{
|
|
object o = ToVarTable(L, stackPos);
|
|
|
|
if (o.GetType() != t)
|
|
{
|
|
LuaDLL.luaL_typerror(L, stackPos, LuaMisc.GetTypeName(t));
|
|
}
|
|
|
|
return o;
|
|
}
|
|
else
|
|
{
|
|
return CheckObject(L, stackPos, t);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (t.IsEnum)
|
|
{
|
|
return ToLua.CheckObject(L, stackPos, t);
|
|
}
|
|
else if ( t == typeof(string))
|
|
{
|
|
return CheckString(L, stackPos);
|
|
}
|
|
else
|
|
{
|
|
return CheckObject(L, stackPos, t);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static UnityEngine.Object CheckUnityObject(IntPtr L, int stackPos, Type type)
|
|
{
|
|
int udata = LuaDLL.tolua_rawnetobj(L, stackPos);
|
|
object obj = null;
|
|
|
|
if (udata != -1)
|
|
{
|
|
ObjectTranslator translator = ObjectTranslator.Get(L);
|
|
obj = translator.GetObject(udata);
|
|
|
|
if (obj != null)
|
|
{
|
|
UnityEngine.Object uObj = (UnityEngine.Object)obj;
|
|
|
|
if (uObj == null)
|
|
{
|
|
LuaDLL.luaL_argerror(L, stackPos, string.Format("{0} expected, got nil", type.FullName));
|
|
return null;
|
|
}
|
|
|
|
Type objType = uObj.GetType();
|
|
|
|
if (type == objType || objType.IsSubclassOf(type))
|
|
{
|
|
return uObj;
|
|
}
|
|
|
|
LuaDLL.luaL_argerror(L, stackPos, string.Format("{0} expected, got {1}", type.FullName, objType.FullName));
|
|
}
|
|
|
|
//传递了tolua.null过来
|
|
return null;
|
|
}
|
|
else if (LuaDLL.lua_isnil(L, stackPos))
|
|
{
|
|
return null;
|
|
}
|
|
|
|
LuaDLL.luaL_typerror(L, stackPos, type.FullName);
|
|
return null;
|
|
}
|
|
|
|
public static UnityEngine.TrackedReference CheckTrackedReference(IntPtr L, int stackPos, Type type)
|
|
{
|
|
int udata = LuaDLL.tolua_rawnetobj(L, stackPos);
|
|
object obj = null;
|
|
|
|
if (udata != -1)
|
|
{
|
|
ObjectTranslator translator = ObjectTranslator.Get(L);
|
|
obj = translator.GetObject(udata);
|
|
|
|
if (obj != null)
|
|
{
|
|
UnityEngine.TrackedReference uObj = (UnityEngine.TrackedReference)obj;
|
|
|
|
if (uObj == null)
|
|
{
|
|
LuaDLL.luaL_argerror(L, stackPos, string.Format("{0} expected, got nil", type.FullName));
|
|
return null;
|
|
}
|
|
|
|
Type objType = uObj.GetType();
|
|
|
|
if (type == objType || objType.IsSubclassOf(type))
|
|
{
|
|
return uObj;
|
|
}
|
|
|
|
LuaDLL.luaL_argerror(L, stackPos, string.Format("{0} expected, got {1}", type.FullName, objType.FullName));
|
|
}
|
|
|
|
return null;
|
|
}
|
|
else if (LuaDLL.lua_isnil(L, stackPos))
|
|
{
|
|
return null;
|
|
}
|
|
|
|
LuaDLL.luaL_typerror(L, stackPos, type.FullName);
|
|
return null;
|
|
}
|
|
|
|
//必须检测类型
|
|
public static object[] CheckObjectArray(IntPtr L, int stackPos)
|
|
{
|
|
LuaTypes luatype = LuaDLL.lua_type(L, stackPos);
|
|
|
|
switch (luatype)
|
|
{
|
|
case LuaTypes.LUA_TNIL:
|
|
return null;
|
|
case LuaTypes.LUA_TTABLE:
|
|
int len = LuaDLL.lua_objlen(L, stackPos);
|
|
object[] list = new object[len];
|
|
int pos = LuaDLL.lua_gettop(L) + 1;
|
|
|
|
for (int i = 1; i <= len; i++)
|
|
{
|
|
LuaDLL.lua_rawgeti(L, stackPos, i);
|
|
list[i - 1] = ToVarObject(L, pos);
|
|
LuaDLL.lua_pop(L, 1);
|
|
}
|
|
return list;
|
|
case LuaTypes.LUA_TUSERDATA:
|
|
return (object[])CheckObject(L, stackPos, typeof(object[]));
|
|
default:
|
|
LuaDLL.luaL_typerror(L, stackPos, "object[] or table");
|
|
return null;
|
|
}
|
|
}
|
|
|
|
public static T[] CheckObjectArray<T>(IntPtr L, int stackPos) where T : class
|
|
{
|
|
LuaTypes luatype = LuaDLL.lua_type(L, stackPos);
|
|
|
|
switch(luatype)
|
|
{
|
|
case LuaTypes.LUA_TNIL:
|
|
return null;
|
|
case LuaTypes.LUA_TTABLE:
|
|
int len = LuaDLL.lua_objlen(L, stackPos);
|
|
T[] list = new T[len];
|
|
int pos = LuaDLL.lua_gettop(L) + 1;
|
|
|
|
for (int i = 1; i <= len; i++)
|
|
{
|
|
LuaDLL.lua_rawgeti(L, stackPos, i);
|
|
|
|
if (!TypeTraits<T>.Check(L, pos))
|
|
{
|
|
LuaDLL.lua_pop(L, 1);
|
|
LuaDLL.luaL_typerror(L, stackPos, typeof(T[]).FullName);
|
|
return list;
|
|
}
|
|
|
|
list[i - 1] = StackTraits<T>.To(L, pos);
|
|
LuaDLL.lua_pop(L, 1);
|
|
}
|
|
return list;
|
|
case LuaTypes.LUA_TUSERDATA:
|
|
return (T[])CheckObject(L, stackPos, typeof(T[]));
|
|
default:
|
|
LuaDLL.luaL_typerror(L, stackPos, TypeTraits<T[]>.GetTypeName());
|
|
return null;
|
|
}
|
|
}
|
|
|
|
public static T[] CheckStructArray<T>(IntPtr L, int stackPos) where T : struct
|
|
{
|
|
LuaTypes luatype = LuaDLL.lua_type(L, stackPos);
|
|
|
|
switch (luatype)
|
|
{
|
|
case LuaTypes.LUA_TTABLE:
|
|
int len = LuaDLL.lua_objlen(L, stackPos);
|
|
T[] list = new T[len];
|
|
int pos = LuaDLL.lua_gettop(L) + 1;
|
|
|
|
for (int i = 1; i <= len; i++)
|
|
{
|
|
LuaDLL.lua_rawgeti(L, stackPos, i);
|
|
|
|
if (!TypeTraits<T>.Check(L, pos))
|
|
{
|
|
LuaDLL.lua_pop(L, 1);
|
|
LuaDLL.luaL_typerror(L, stackPos, typeof(T[]).FullName);
|
|
return list;
|
|
}
|
|
|
|
list[i-1] = StackTraits<T>.To(L, pos);
|
|
LuaDLL.lua_pop(L, 1);
|
|
}
|
|
return list;
|
|
case LuaTypes.LUA_TUSERDATA:
|
|
return (T[])CheckObject(L, stackPos, typeof(T[]));
|
|
default:
|
|
LuaDLL.luaL_typerror(L, stackPos, TypeTraits<T[]>.GetTypeName());
|
|
return null;
|
|
}
|
|
}
|
|
|
|
public static char[] CheckCharBuffer(IntPtr L, int stackPos)
|
|
{
|
|
LuaTypes luaType = LuaDLL.lua_type(L, stackPos);
|
|
|
|
switch (luaType)
|
|
{
|
|
case LuaTypes.LUA_TNIL:
|
|
return null;
|
|
case LuaTypes.LUA_TSTRING:
|
|
string str = LuaDLL.lua_tostring(L, stackPos);
|
|
return str.ToCharArray(); ;
|
|
case LuaTypes.LUA_TUSERDATA:
|
|
return (char[])CheckObject(L, stackPos, typeof(char[]));
|
|
default:
|
|
LuaDLL.luaL_typerror(L, stackPos, "string or char[]");
|
|
return null;
|
|
}
|
|
}
|
|
|
|
public static byte[] CheckByteBuffer(IntPtr L, int stackPos)
|
|
{
|
|
LuaTypes luaType = LuaDLL.lua_type(L, stackPos);
|
|
|
|
switch (luaType)
|
|
{
|
|
case LuaTypes.LUA_TNIL:
|
|
return null;
|
|
case LuaTypes.LUA_TSTRING:
|
|
int len;
|
|
IntPtr source = LuaDLL.lua_tolstring(L, stackPos, out len);
|
|
byte[] buffer = new byte[len];
|
|
Marshal.Copy(source, buffer, 0, len);
|
|
return buffer;
|
|
case LuaTypes.LUA_TUSERDATA:
|
|
return (byte[])CheckObject(L, stackPos, typeof(byte[]));
|
|
default:
|
|
LuaDLL.luaL_typerror(L, stackPos, "string or byte[]");
|
|
return null;
|
|
}
|
|
}
|
|
|
|
public static T[] CheckNumberArray<T>(IntPtr L, int stackPos) where T : struct
|
|
{
|
|
LuaTypes luatype = LuaDLL.lua_type(L, stackPos);
|
|
|
|
switch(luatype)
|
|
{
|
|
case LuaTypes.LUA_TNIL:
|
|
return null;
|
|
case LuaTypes.LUA_TTABLE:
|
|
int len = LuaDLL.lua_objlen(L, stackPos);
|
|
T[] list = new T[len];
|
|
int pos = LuaDLL.lua_gettop(L) + 1;
|
|
|
|
for (int i = 1; i <= len; i++)
|
|
{
|
|
LuaDLL.lua_rawgeti(L, stackPos, i);
|
|
|
|
if (!TypeTraits<T>.Check(L, pos))
|
|
{
|
|
LuaDLL.lua_pop(L, 1);
|
|
LuaDLL.luaL_typerror(L, stackPos, TypeTraits<T[]>.GetTypeName());
|
|
return list;
|
|
}
|
|
|
|
list[i - 1] = StackTraits<T>.To(L, pos);
|
|
LuaDLL.lua_pop(L, 1);
|
|
}
|
|
|
|
return list;
|
|
case LuaTypes.LUA_TUSERDATA:
|
|
return (T[])CheckObject(L, stackPos, typeof(T[]));
|
|
default:
|
|
LuaDLL.luaL_typerror(L, stackPos, TypeTraits<T[]>.GetTypeName());
|
|
return null;
|
|
}
|
|
}
|
|
|
|
|
|
public static bool[] CheckBoolArray(IntPtr L, int stackPos)
|
|
{
|
|
LuaTypes luatype = LuaDLL.lua_type(L, stackPos);
|
|
|
|
switch(luatype)
|
|
{
|
|
case LuaTypes.LUA_TNIL:
|
|
return null;
|
|
case LuaTypes.LUA_TTABLE:
|
|
int len = LuaDLL.lua_objlen(L, stackPos);
|
|
bool[] list = new bool[len];
|
|
int pos = LuaDLL.lua_gettop(L) + 1;
|
|
|
|
for (int i = 1; i <= len; i++)
|
|
{
|
|
LuaDLL.lua_rawgeti(L, stackPos, i);
|
|
|
|
if (LuaDLL.lua_type(L, pos) != LuaTypes.LUA_TBOOLEAN)
|
|
{
|
|
LuaDLL.lua_pop(L, 1);
|
|
LuaDLL.luaL_typerror(L, stackPos, "bool[]");
|
|
return list;
|
|
}
|
|
|
|
list[i - 1] = LuaDLL.lua_toboolean(L, pos);
|
|
LuaDLL.lua_pop(L, 1);
|
|
}
|
|
|
|
return list;
|
|
case LuaTypes.LUA_TUSERDATA:
|
|
return (bool[])CheckObject(L, stackPos, typeof(bool[]));
|
|
default:
|
|
LuaDLL.luaL_typerror(L, stackPos, "bool[]");
|
|
return null;
|
|
}
|
|
}
|
|
|
|
public static string[] CheckStringArray(IntPtr L, int stackPos)
|
|
{
|
|
LuaTypes luatype = LuaDLL.lua_type(L, stackPos);
|
|
|
|
switch(luatype)
|
|
{
|
|
case LuaTypes.LUA_TNIL:
|
|
return null;
|
|
case LuaTypes.LUA_TTABLE:
|
|
int len = LuaDLL.lua_objlen(L, stackPos);
|
|
string[] list = new string[len];
|
|
int pos = LuaDLL.lua_gettop(L) + 1;
|
|
|
|
for (int i = 1; i <= len; i++)
|
|
{
|
|
LuaDLL.lua_rawgeti(L, stackPos, i);
|
|
|
|
if (!TypeTraits<string>.Check(L, pos))
|
|
{
|
|
LuaDLL.lua_pop(L, 1);
|
|
LuaDLL.luaL_typerror(L, stackPos, "string[]");
|
|
return list;
|
|
}
|
|
|
|
list[i - 1] = StackTraits<string>.To(L, pos);
|
|
LuaDLL.lua_pop(L, 1);
|
|
}
|
|
return list;
|
|
case LuaTypes.LUA_TUSERDATA:
|
|
return (string[])CheckObject(L, stackPos, typeof(string[]));
|
|
default:
|
|
LuaDLL.luaL_typerror(L, stackPos, "string[]");
|
|
return null;
|
|
}
|
|
}
|
|
|
|
public static object CheckGenericObject(IntPtr L, int stackPos, Type type, out Type ArgType)
|
|
{
|
|
object obj = ToLua.ToObject(L, 1);
|
|
Type t = obj.GetType();
|
|
ArgType = null;
|
|
|
|
if (t.IsGenericType && t.GetGenericTypeDefinition() == type)
|
|
{
|
|
Type[] ts = t.GetGenericArguments();
|
|
ArgType = ts[0];
|
|
return obj;
|
|
}
|
|
|
|
LuaDLL.luaL_argerror(L, stackPos, LuaMisc.GetTypeName(type));
|
|
return null;
|
|
}
|
|
|
|
public static object CheckGenericObject(IntPtr L, int stackPos, Type type, out Type t1, out Type t2)
|
|
{
|
|
object obj = ToLua.ToObject(L, 1);
|
|
Type t = obj.GetType();
|
|
t1 = null;
|
|
t2 = null;
|
|
|
|
if (t.IsGenericType && t.GetGenericTypeDefinition() == type)
|
|
{
|
|
Type[] ts = t.GetGenericArguments();
|
|
t1 = ts[0];
|
|
t2 = ts[1];
|
|
return obj;
|
|
}
|
|
|
|
LuaDLL.luaL_argerror(L, stackPos, LuaMisc.GetTypeName(type));
|
|
return null;
|
|
}
|
|
|
|
public static object CheckGenericObject(IntPtr L, int stackPos, Type type)
|
|
{
|
|
object obj = ToLua.ToObject(L, 1);
|
|
Type t = obj.GetType();
|
|
|
|
if (t.IsGenericType && t.GetGenericTypeDefinition() == type)
|
|
{
|
|
return obj;
|
|
}
|
|
|
|
LuaDLL.luaL_argerror(L, stackPos, LuaMisc.GetTypeName(type));
|
|
return null;
|
|
}
|
|
|
|
public static object[] ToParamsObject(IntPtr L, int stackPos, int count)
|
|
{
|
|
if (count <= 0)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
object[] list = new object[count];
|
|
int pos = 0;
|
|
|
|
while (pos < count)
|
|
{
|
|
list[pos++] = ToVarObject(L, stackPos++);
|
|
}
|
|
|
|
return list;
|
|
}
|
|
|
|
public static T[] ToParamsObject<T>(IntPtr L, int stackPos, int count)
|
|
{
|
|
if (count <= 0)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
T[] list = new T[count];
|
|
int pos = 0;
|
|
|
|
while (pos < count)
|
|
{
|
|
list[pos++] = StackTraits<T>.To(L, stackPos++);
|
|
}
|
|
|
|
return list;
|
|
}
|
|
|
|
public static string[] ToParamsString(IntPtr L, int stackPos, int count)
|
|
{
|
|
if (count <= 0)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
string[] list = new string[count];
|
|
int pos = 0;
|
|
|
|
while (pos < count)
|
|
{
|
|
list[pos++] = ToString(L, stackPos++);
|
|
}
|
|
|
|
return list;
|
|
}
|
|
|
|
public static T[] ToParamsNumber<T>(IntPtr L, int stackPos, int count) where T : struct
|
|
{
|
|
if (count <= 0)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
T[] list = new T[count];
|
|
int pos = 0;
|
|
|
|
while (pos < count)
|
|
{
|
|
list[pos++] = StackTraits<T>.To(L, stackPos++);
|
|
}
|
|
|
|
return list;
|
|
}
|
|
|
|
public static char[] ToParamsChar(IntPtr L, int stackPos, int count)
|
|
{
|
|
if (count <= 0)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
char[] list = new char[count];
|
|
int pos = 0;
|
|
|
|
while (pos < count)
|
|
{
|
|
list[pos++] = (char)LuaDLL.lua_tointeger(L, stackPos++);
|
|
}
|
|
|
|
return list;
|
|
}
|
|
|
|
public static bool[] CheckParamsBool(IntPtr L, int stackPos, int count)
|
|
{
|
|
if (count <= 0)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
bool[] list = new bool[count];
|
|
int pos = 0;
|
|
|
|
while (pos < count)
|
|
{
|
|
list[pos++] = LuaDLL.luaL_checkboolean(L, stackPos++);
|
|
}
|
|
|
|
return list;
|
|
}
|
|
|
|
public static T[] CheckParamsNumber<T>(IntPtr L, int stackPos, int count) where T : struct
|
|
{
|
|
if (count <= 0)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
T[] list = new T[count];
|
|
int pos = 0;
|
|
|
|
while (pos < count)
|
|
{
|
|
list[pos++] = StackTraits<T>.Check(L, stackPos++);
|
|
}
|
|
|
|
return list;
|
|
}
|
|
|
|
public static char[] CheckParamsChar(IntPtr L, int stackPos, int count)
|
|
{
|
|
if (count <= 0)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
char[] list = new char[count];
|
|
int pos = 0;
|
|
|
|
while (pos < count)
|
|
{
|
|
list[pos++] = (char)LuaDLL.luaL_checkinteger(L, stackPos++);
|
|
}
|
|
|
|
return list;
|
|
}
|
|
|
|
public static string[] CheckParamsString(IntPtr L, int stackPos, int count)
|
|
{
|
|
if (count <= 0)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
string[] list = new string[count];
|
|
int pos = 0;
|
|
|
|
while (pos < count)
|
|
{
|
|
list[pos++] = CheckString(L, stackPos++);
|
|
}
|
|
|
|
return list;
|
|
}
|
|
|
|
public static T[] CheckParamsObject<T>(IntPtr L, int stackPos, int count)
|
|
{
|
|
if (count <= 0)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
T[] list = new T[count];
|
|
int pos = 0;
|
|
|
|
while (pos < count)
|
|
{
|
|
list[pos++] = StackTraits<T>.Check(L, stackPos++);
|
|
}
|
|
|
|
return list;
|
|
}
|
|
|
|
static public char[] ToCharBuffer(IntPtr L, int stackPos)
|
|
{
|
|
LuaTypes luaType = LuaDLL.lua_type(L, stackPos);
|
|
|
|
switch (luaType)
|
|
{
|
|
case LuaTypes.LUA_TNIL:
|
|
return null;
|
|
case LuaTypes.LUA_TSTRING:
|
|
string str = LuaDLL.lua_tostring(L, stackPos);
|
|
return str.ToCharArray();
|
|
case LuaTypes.LUA_TUSERDATA:
|
|
return (char[])ToObject(L, stackPos);
|
|
default:
|
|
return null;
|
|
}
|
|
}
|
|
|
|
static public byte[] ToByteBuffer(IntPtr L, int stackPos)
|
|
{
|
|
LuaTypes luaType = LuaDLL.lua_type(L, stackPos);
|
|
|
|
switch (luaType)
|
|
{
|
|
case LuaTypes.LUA_TNIL:
|
|
return null;
|
|
case LuaTypes.LUA_TSTRING:
|
|
int len;
|
|
IntPtr source = LuaDLL.lua_tolstring(L, stackPos, out len);
|
|
byte[] buffer = new byte[len];
|
|
Marshal.Copy(source, buffer, 0, len);
|
|
return buffer;
|
|
case LuaTypes.LUA_TUSERDATA:
|
|
return (byte[])ToObject(L, stackPos);
|
|
default:
|
|
return null;
|
|
}
|
|
}
|
|
|
|
public static T[] ToNumberArray<T>(IntPtr L, int stackPos) where T : struct
|
|
{
|
|
LuaTypes luatype = LuaDLL.lua_type(L, stackPos);
|
|
|
|
switch (luatype)
|
|
{
|
|
case LuaTypes.LUA_TNIL:
|
|
return null;
|
|
case LuaTypes.LUA_TTABLE:
|
|
int len = LuaDLL.lua_objlen(L, stackPos);
|
|
T[] list = new T[len];
|
|
int pos = LuaDLL.lua_gettop(L) + 1;
|
|
|
|
for (int i = 1; i <= len; i++)
|
|
{
|
|
LuaDLL.lua_rawgeti(L, stackPos, i);
|
|
|
|
if (!TypeTraits<T>.Check(L, pos))
|
|
{
|
|
LuaDLL.lua_pop(L, 1);
|
|
LuaDLL.luaL_typerror(L, stackPos, TypeTraits<T[]>.GetTypeName());
|
|
return list;
|
|
}
|
|
|
|
list[i - 1] = StackTraits<T>.To(L, pos);
|
|
LuaDLL.lua_pop(L, 1);
|
|
}
|
|
|
|
return list;
|
|
case LuaTypes.LUA_TUSERDATA:
|
|
return (T[])ToObject(L, stackPos);
|
|
default:
|
|
return null;
|
|
}
|
|
}
|
|
|
|
public static bool[] ToBoolArray(IntPtr L, int stackPos)
|
|
{
|
|
LuaTypes luatype = LuaDLL.lua_type(L, stackPos);
|
|
|
|
switch (luatype)
|
|
{
|
|
case LuaTypes.LUA_TNIL:
|
|
return null;
|
|
case LuaTypes.LUA_TTABLE:
|
|
int len = LuaDLL.lua_objlen(L, stackPos);
|
|
bool[] list = new bool[len];
|
|
int pos = LuaDLL.lua_gettop(L) + 1;
|
|
|
|
for (int i = 1; i <= len; i++)
|
|
{
|
|
LuaDLL.lua_rawgeti(L, stackPos, i);
|
|
|
|
if (LuaDLL.lua_type(L, pos) != LuaTypes.LUA_TBOOLEAN)
|
|
{
|
|
LuaDLL.lua_pop(L, 1);
|
|
LuaDLL.luaL_typerror(L, stackPos, "bool[]");
|
|
return list;
|
|
}
|
|
|
|
list[i - 1] = LuaDLL.lua_toboolean(L, pos);
|
|
LuaDLL.lua_pop(L, 1);
|
|
}
|
|
|
|
return list;
|
|
case LuaTypes.LUA_TUSERDATA:
|
|
return (bool[])ToObject(L, stackPos);
|
|
default:
|
|
return null;
|
|
}
|
|
}
|
|
|
|
|
|
public static string[] ToStringArray(IntPtr L, int stackPos)
|
|
{
|
|
LuaTypes luatype = LuaDLL.lua_type(L, stackPos);
|
|
|
|
switch(luatype)
|
|
{
|
|
case LuaTypes.LUA_TNIL:
|
|
return null;
|
|
case LuaTypes.LUA_TTABLE:
|
|
int len = LuaDLL.lua_objlen(L, stackPos);
|
|
string[] list = new string[len];
|
|
int pos = LuaDLL.lua_gettop(L) + 1;
|
|
|
|
for (int i = 1; i <= len; i++)
|
|
{
|
|
LuaDLL.lua_rawgeti(L, stackPos, i);
|
|
|
|
if (!TypeTraits<string>.Check(L, pos))
|
|
{
|
|
LuaDLL.lua_pop(L, 1);
|
|
LuaDLL.luaL_typerror(L, stackPos, "string[]");
|
|
return list;
|
|
}
|
|
|
|
list[i - 1] = StackTraits<string>.To(L, pos);
|
|
LuaDLL.lua_pop(L, 1);
|
|
}
|
|
return list;
|
|
case LuaTypes.LUA_TUSERDATA:
|
|
return (string[])ToObject(L, stackPos);
|
|
default:
|
|
return null;
|
|
}
|
|
}
|
|
|
|
public static object[] ToObjectArray(IntPtr L, int stackPos)
|
|
{
|
|
LuaTypes luatype = LuaDLL.lua_type(L, stackPos);
|
|
|
|
switch(luatype)
|
|
{
|
|
case LuaTypes.LUA_TNIL:
|
|
return null;
|
|
case LuaTypes.LUA_TTABLE:
|
|
int len = LuaDLL.lua_objlen(L, stackPos);
|
|
object[] list = new object[len];
|
|
int pos = LuaDLL.lua_gettop(L) + 1;
|
|
|
|
for (int i = 1; i <= len; i++)
|
|
{
|
|
LuaDLL.lua_rawgeti(L, stackPos, i);
|
|
list[i - 1] = ToVarObject(L, pos);
|
|
LuaDLL.lua_pop(L, 1);
|
|
}
|
|
return list;
|
|
case LuaTypes.LUA_TUSERDATA:
|
|
return (object[])ToObject(L, stackPos);
|
|
default:
|
|
return null;
|
|
}
|
|
}
|
|
|
|
|
|
public static T[] ToObjectArray<T>(IntPtr L, int stackPos) where T : class
|
|
{
|
|
LuaTypes luatype = LuaDLL.lua_type(L, stackPos);
|
|
|
|
switch (luatype)
|
|
{
|
|
case LuaTypes.LUA_TNIL:
|
|
return null;
|
|
case LuaTypes.LUA_TTABLE:
|
|
int len = LuaDLL.lua_objlen(L, stackPos);
|
|
T[] list = new T[len];
|
|
int pos = LuaDLL.lua_gettop(L) + 1;
|
|
|
|
for (int i = 1; i <= len; i++)
|
|
{
|
|
LuaDLL.lua_rawgeti(L, stackPos, i);
|
|
|
|
if (!TypeTraits<T>.Check(L, pos))
|
|
{
|
|
LuaDLL.lua_pop(L, 1);
|
|
LuaDLL.luaL_typerror(L, stackPos, typeof(T[]).FullName);
|
|
return list;
|
|
}
|
|
|
|
list[i - 1] = StackTraits<T>.To(L, pos);
|
|
LuaDLL.lua_pop(L, 1);
|
|
}
|
|
return list;
|
|
case LuaTypes.LUA_TUSERDATA:
|
|
return (T[])ToObject(L, stackPos);
|
|
default:
|
|
return null;
|
|
}
|
|
}
|
|
|
|
|
|
public static T[] ToStructArray<T>(IntPtr L, int stackPos) where T : struct
|
|
{
|
|
LuaTypes luatype = LuaDLL.lua_type(L, stackPos);
|
|
|
|
switch (luatype)
|
|
{
|
|
case LuaTypes.LUA_TNIL:
|
|
return null;
|
|
case LuaTypes.LUA_TTABLE:
|
|
int len = LuaDLL.lua_objlen(L, stackPos);
|
|
T[] list = new T[len];
|
|
int pos = LuaDLL.lua_gettop(L) + 1;
|
|
|
|
for (int i = 1; i <= len; i++)
|
|
{
|
|
LuaDLL.lua_rawgeti(L, stackPos, i);
|
|
|
|
if (!TypeTraits<T>.Check(L, pos))
|
|
{
|
|
LuaDLL.lua_pop(L, 1);
|
|
LuaDLL.luaL_typerror(L, stackPos, typeof(T[]).FullName);
|
|
return list;
|
|
}
|
|
|
|
list[i - 1] = StackTraits<T>.To(L, pos);
|
|
LuaDLL.lua_pop(L, 1);
|
|
}
|
|
return list;
|
|
case LuaTypes.LUA_TUSERDATA:
|
|
return (T[])ToObject(L, stackPos);
|
|
default:
|
|
return null;
|
|
}
|
|
}
|
|
|
|
|
|
public static void Push(IntPtr L, Vector3 v3)
|
|
{
|
|
LuaDLL.tolua_pushvec3(L, v3.x, v3.y, v3.z);
|
|
}
|
|
|
|
public static void Push(IntPtr L, Vector2 v2)
|
|
{
|
|
LuaDLL.tolua_pushvec2(L, v2.x, v2.y);
|
|
}
|
|
|
|
public static void Push(IntPtr L, Vector4 v4)
|
|
{
|
|
LuaDLL.tolua_pushvec4(L, v4.x, v4.y, v4.z, v4.w);
|
|
}
|
|
|
|
public static void Push(IntPtr L, Quaternion q)
|
|
{
|
|
LuaDLL.tolua_pushquat(L, q.x, q.y, q.z, q.w);
|
|
}
|
|
|
|
public static void Push(IntPtr L, Color clr)
|
|
{
|
|
LuaDLL.tolua_pushclr(L, clr.r, clr.g, clr.b, clr.a);
|
|
}
|
|
|
|
public static void Push(IntPtr L, Ray ray)
|
|
{
|
|
LuaStatic.GetPackRay(L);
|
|
Push(L, ray.direction);
|
|
Push(L, ray.origin);
|
|
|
|
if (LuaDLL.lua_pcall(L, 2, 1, 0) != 0)
|
|
{
|
|
string error = LuaDLL.lua_tostring(L, -1);
|
|
throw new LuaException(error);
|
|
}
|
|
}
|
|
|
|
public static void Push(IntPtr L, Bounds bound)
|
|
{
|
|
LuaStatic.GetPackBounds(L);
|
|
Push(L, bound.center);
|
|
Push(L, bound.size);
|
|
|
|
if (LuaDLL.lua_pcall(L, 2, 1, 0) != 0)
|
|
{
|
|
string error = LuaDLL.lua_tostring(L, -1);
|
|
throw new LuaException(error);
|
|
}
|
|
}
|
|
|
|
public static void Push(IntPtr L, RaycastHit hit)
|
|
{
|
|
LuaStatic.GetPackRaycastHit(L);
|
|
Push(L, hit.collider);
|
|
LuaDLL.lua_pushnumber(L, hit.distance);
|
|
Push(L, hit.normal);
|
|
Push(L, hit.point);
|
|
Push(L, hit.rigidbody);
|
|
Push(L, hit.transform);
|
|
|
|
if (LuaDLL.lua_pcall(L, 6, 1, 0) != 0)
|
|
{
|
|
string error = LuaDLL.lua_tostring(L, -1);
|
|
throw new LuaException(error);
|
|
}
|
|
}
|
|
|
|
public static void Push(IntPtr L, RaycastHit hit, int flag)
|
|
{
|
|
LuaStatic.GetPackRaycastHit(L);
|
|
|
|
if ((flag & RaycastBits.Collider) != 0)
|
|
{
|
|
Push(L, hit.collider);
|
|
}
|
|
else
|
|
{
|
|
LuaDLL.lua_pushnil(L);
|
|
}
|
|
|
|
LuaDLL.lua_pushnumber(L, hit.distance);
|
|
|
|
if ((flag & RaycastBits.Normal) != 0)
|
|
{
|
|
Push(L, hit.normal);
|
|
}
|
|
else
|
|
{
|
|
LuaDLL.lua_pushnil(L);
|
|
}
|
|
|
|
if ((flag & RaycastBits.Point) != 0)
|
|
{
|
|
Push(L, hit.point);
|
|
}
|
|
else
|
|
{
|
|
LuaDLL.lua_pushnil(L);
|
|
}
|
|
|
|
if ((flag & RaycastBits.Rigidbody) != 0)
|
|
{
|
|
Push(L, hit.rigidbody);
|
|
}
|
|
else
|
|
{
|
|
LuaDLL.lua_pushnil(L);
|
|
}
|
|
|
|
if ((flag & RaycastBits.Transform) != 0)
|
|
{
|
|
Push(L, hit.transform);
|
|
}
|
|
else
|
|
{
|
|
LuaDLL.lua_pushnil(L);
|
|
}
|
|
|
|
if (LuaDLL.lua_pcall(L, 6, 1, 0) != 0)
|
|
{
|
|
string error = LuaDLL.lua_tostring(L, -1);
|
|
throw new LuaException(error);
|
|
}
|
|
}
|
|
|
|
public static void Push(IntPtr L, Touch t)
|
|
{
|
|
Push(L, t, TouchBits.ALL);
|
|
}
|
|
|
|
public static void Push(IntPtr L, Touch t, int flag)
|
|
{
|
|
LuaStatic.GetPackTouch(L);
|
|
LuaDLL.lua_pushinteger(L, t.fingerId);
|
|
|
|
if ((flag & TouchBits.Position) != 0)
|
|
{
|
|
Push(L, t.position);
|
|
}
|
|
else
|
|
{
|
|
LuaDLL.lua_pushnil(L);
|
|
}
|
|
|
|
if ((flag & TouchBits.RawPosition) != 0)
|
|
{
|
|
Push(L, t.rawPosition);
|
|
}
|
|
else
|
|
{
|
|
LuaDLL.lua_pushnil(L);
|
|
}
|
|
|
|
if ((flag & TouchBits.DeltaPosition) != 0)
|
|
{
|
|
Push(L, t.deltaPosition);
|
|
}
|
|
else
|
|
{
|
|
LuaDLL.lua_pushnil(L);
|
|
}
|
|
|
|
LuaDLL.lua_pushnumber(L, t.deltaTime);
|
|
LuaDLL.lua_pushinteger(L, t.tapCount);
|
|
LuaDLL.lua_pushinteger(L, (int)t.phase);
|
|
|
|
if (LuaDLL.lua_pcall(L, 7, -1, 0) != 0)
|
|
{
|
|
string error = LuaDLL.lua_tostring(L, -1);
|
|
throw new LuaException(error);
|
|
}
|
|
}
|
|
|
|
public static void PushLayerMask(IntPtr L, LayerMask l)
|
|
{
|
|
LuaDLL.tolua_pushlayermask(L, l.value);
|
|
}
|
|
|
|
public static void Push(IntPtr L, LuaByteBuffer bb)
|
|
{
|
|
LuaDLL.lua_pushlstring(L, bb.buffer, bb.buffer.Length);
|
|
}
|
|
|
|
public static void PushByteBuffer(IntPtr L, byte[] buffer)
|
|
{
|
|
LuaDLL.tolua_pushlstring(L, buffer, buffer.Length);
|
|
}
|
|
|
|
public static void Push(IntPtr L, Array array)
|
|
{
|
|
if (array == null)
|
|
{
|
|
LuaDLL.lua_pushnil(L);
|
|
}
|
|
else
|
|
{
|
|
int arrayMetaTable = LuaStatic.GetArrayMetatable(L);
|
|
PushUserData(L, array, arrayMetaTable);
|
|
}
|
|
}
|
|
|
|
public static void Push(IntPtr L, LuaBaseRef lbr)
|
|
{
|
|
if (lbr == null)
|
|
{
|
|
LuaDLL.lua_pushnil(L);
|
|
}
|
|
else
|
|
{
|
|
LuaDLL.lua_getref(L, lbr.GetReference());
|
|
}
|
|
}
|
|
|
|
public static void Push(IntPtr L, Type t)
|
|
{
|
|
if (t == null)
|
|
{
|
|
LuaDLL.lua_pushnil(L);
|
|
}
|
|
else
|
|
{
|
|
int typeMetatable = LuaStatic.GetTypeMetatable(L);
|
|
PushUserData(L, t, typeMetatable);
|
|
}
|
|
}
|
|
|
|
public static void Push(IntPtr L, Delegate ev)
|
|
{
|
|
if (ev == null)
|
|
{
|
|
LuaDLL.lua_pushnil(L);
|
|
}
|
|
else
|
|
{
|
|
int delegateMetatable = LuaStatic.GetDelegateMetatable(L);
|
|
PushUserData(L, ev, delegateMetatable);
|
|
}
|
|
}
|
|
|
|
public static void Push(IntPtr L, EventObject ev)
|
|
{
|
|
if (ev == null)
|
|
{
|
|
LuaDLL.lua_pushnil(L);
|
|
}
|
|
else
|
|
{
|
|
int eventMetatable = LuaStatic.GetEventMetatable(L);
|
|
PushUserData(L, ev, eventMetatable);
|
|
}
|
|
}
|
|
|
|
public static void Push(IntPtr L, IEnumerator iter)
|
|
{
|
|
if (iter == null)
|
|
{
|
|
LuaDLL.lua_pushnil(L);
|
|
}
|
|
else
|
|
{
|
|
int reference = LuaStatic.GetMetaReference(L, iter.GetType());
|
|
|
|
if (reference > 0)
|
|
{
|
|
PushUserData(L, iter, reference);
|
|
}
|
|
else
|
|
{
|
|
int iterMetatable = LuaStatic.GetIterMetatable(L);
|
|
PushUserData(L, iter, iterMetatable);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static void Push(IntPtr L, System.Enum e)
|
|
{
|
|
object obj = null;
|
|
int enumMetatable = LuaStatic.GetEnumObject(L, e, out obj);
|
|
PushUserData(L, obj, enumMetatable);
|
|
}
|
|
|
|
//基础类型获取需要一个函数
|
|
public static void PushOut<T>(IntPtr L, LuaOut<T> lo)
|
|
{
|
|
ObjectTranslator translator = ObjectTranslator.Get(L);
|
|
int index = translator.AddObject(lo);
|
|
LuaDLL.tolua_pushnewudata(L, LuaIndexes.LUA_REGISTRYINDEX, index);
|
|
}
|
|
|
|
public static void PushStruct(IntPtr L, object o)
|
|
{
|
|
if (o == null || o.Equals(null))
|
|
{
|
|
LuaDLL.lua_pushnil(L);
|
|
return;
|
|
}
|
|
|
|
if (o is Enum)
|
|
{
|
|
ToLua.Push(L, (Enum)o);
|
|
return;
|
|
}
|
|
|
|
Type type = o.GetType();
|
|
int reference = LuaStatic.GetMetaReference(L, type);
|
|
|
|
if (reference <= 0)
|
|
{
|
|
reference = LoadPreType(L, type);
|
|
}
|
|
|
|
ObjectTranslator translator = ObjectTranslator.Get(L);
|
|
int index = translator.AddObject(o);
|
|
LuaDLL.tolua_pushnewudata(L, reference, index);
|
|
}
|
|
|
|
public static void PushValue<T>(IntPtr L, T v) where T : struct
|
|
{
|
|
StackTraits<T>.Push(L, v);
|
|
}
|
|
|
|
public static void PusNullable<T>(IntPtr L, Nullable<T> v) where T : struct
|
|
{
|
|
if (v == null)
|
|
{
|
|
LuaDLL.lua_pushnil(L);
|
|
return;
|
|
}
|
|
|
|
StackTraits<T>.Push(L, v.Value);
|
|
}
|
|
|
|
public static void PushUserData(IntPtr L, object o, int reference)
|
|
{
|
|
int index;
|
|
ObjectTranslator translator = ObjectTranslator.Get(L);
|
|
|
|
if (translator.Getudata(o, out index))
|
|
{
|
|
if (LuaDLL.tolua_pushudata(L, index))
|
|
{
|
|
return;
|
|
}
|
|
|
|
translator.Destroyudata(index);
|
|
}
|
|
|
|
index = translator.AddObject(o);
|
|
LuaDLL.tolua_pushnewudata(L, reference, index);
|
|
}
|
|
|
|
static int LuaPCall(IntPtr L, LuaCSFunction func)
|
|
{
|
|
int top = LuaDLL.lua_gettop(L);
|
|
LuaDLL.tolua_pushcfunction(L, func);
|
|
|
|
if (LuaDLL.lua_pcall(L, 0, -1, 0) != 0)
|
|
{
|
|
string error = LuaDLL.lua_tostring(L, -1);
|
|
LuaDLL.lua_settop(L, top);
|
|
throw new LuaException(error, LuaException.GetLastError());
|
|
}
|
|
|
|
int reference = LuaDLL.tolua_getclassref(L, -1);
|
|
LuaDLL.lua_settop(L, top);
|
|
return reference;
|
|
}
|
|
|
|
public static int LoadPreType(IntPtr L, Type type)
|
|
{
|
|
LuaCSFunction LuaOpenLib = LuaStatic.GetPreModule(L, type);
|
|
int reference = -1;
|
|
|
|
if (LuaOpenLib != null)
|
|
{
|
|
#if UNITY_EDITOR
|
|
Debugger.LogWarning("register PreLoad type {0} to lua", LuaMisc.GetTypeName(type));
|
|
#endif
|
|
reference = LuaPCall(L, LuaOpenLib);
|
|
}
|
|
else
|
|
{
|
|
//类型未Wrap
|
|
reference = LuaStatic.GetMissMetaReference(L, type);
|
|
}
|
|
|
|
return reference;
|
|
}
|
|
|
|
//o 不为 null
|
|
static void PushUserObject(IntPtr L, object o)
|
|
{
|
|
Type type = o.GetType();
|
|
int reference = LuaStatic.GetMetaReference(L, type);
|
|
|
|
if (reference <= 0)
|
|
{
|
|
reference = LoadPreType(L, type);
|
|
}
|
|
|
|
PushUserData(L, o, reference);
|
|
}
|
|
|
|
public static void Push(IntPtr L, UnityEngine.Object obj)
|
|
{
|
|
if (obj == null)
|
|
{
|
|
LuaDLL.lua_pushnil(L);
|
|
}
|
|
else
|
|
{
|
|
PushUserObject(L, obj);
|
|
}
|
|
}
|
|
|
|
public static void Push(IntPtr L, UnityEngine.TrackedReference obj)
|
|
{
|
|
if (obj == null)
|
|
{
|
|
LuaDLL.lua_pushnil(L);
|
|
}
|
|
else
|
|
{
|
|
PushUserObject(L, obj);
|
|
}
|
|
}
|
|
|
|
public static void PushSealed<T>(IntPtr L, T o)
|
|
{
|
|
if (o == null || o.Equals(null))
|
|
{
|
|
LuaDLL.lua_pushnil(L);
|
|
}
|
|
else
|
|
{
|
|
int reference = TypeTraits<T>.GetLuaReference(L);
|
|
|
|
if (reference <= 0)
|
|
{
|
|
reference = LoadPreType(L, o.GetType());
|
|
}
|
|
|
|
ToLua.PushUserData(L, o, reference);
|
|
}
|
|
}
|
|
|
|
public static void PushObject(IntPtr L, object o)
|
|
{
|
|
if (o == null || o.Equals(null))
|
|
{
|
|
LuaDLL.lua_pushnil(L);
|
|
}
|
|
else
|
|
{
|
|
if (o is Enum)
|
|
{
|
|
ToLua.Push(L, (Enum)o);
|
|
}
|
|
else
|
|
{
|
|
PushUserObject(L, o);
|
|
}
|
|
}
|
|
}
|
|
|
|
/*static void PushNull(IntPtr L)
|
|
{
|
|
LuaDLL.tolua_pushudata(L, 1);
|
|
}*/
|
|
|
|
public static void Push(IntPtr L, nil obj)
|
|
{
|
|
LuaDLL.lua_pushnil(L);
|
|
}
|
|
|
|
//PushVarObject
|
|
public static void Push(IntPtr L, object obj)
|
|
{
|
|
if (obj == null || obj.Equals(null))
|
|
{
|
|
LuaDLL.lua_pushnil(L);
|
|
return;
|
|
}
|
|
|
|
Type t = obj.GetType();
|
|
|
|
if (t.IsValueType)
|
|
{
|
|
if (TypeChecker.IsNullable(t))
|
|
{
|
|
Type[] ts = t.GetGenericArguments();
|
|
t = ts[0];
|
|
}
|
|
|
|
if (t == typeof(bool))
|
|
{
|
|
bool b = (bool)obj;
|
|
LuaDLL.lua_pushboolean(L, b);
|
|
}
|
|
else if (obj is Enum)
|
|
{
|
|
Push(L, (System.Enum)obj);
|
|
}
|
|
else if (t == typeof(long))
|
|
{
|
|
LuaDLL.tolua_pushint64(L, (long)obj);
|
|
}
|
|
else if (t == typeof(ulong))
|
|
{
|
|
LuaDLL.tolua_pushuint64(L, (ulong)obj);
|
|
}
|
|
else if (t.IsPrimitive)
|
|
{
|
|
double d = LuaMisc.ToDouble(obj);
|
|
LuaDLL.lua_pushnumber(L, d);
|
|
}
|
|
else if (t == typeof(LuaByteBuffer))
|
|
{
|
|
LuaByteBuffer lbb = (LuaByteBuffer)obj;
|
|
LuaDLL.lua_pushlstring(L, lbb.buffer, lbb.buffer.Length);
|
|
}
|
|
else if (t == typeof(Vector3))
|
|
{
|
|
Push(L, (Vector3)obj);
|
|
}
|
|
else if (t == typeof(Quaternion))
|
|
{
|
|
Push(L, (Quaternion)obj);
|
|
}
|
|
else if (t == typeof(Vector2))
|
|
{
|
|
Push(L, (Vector2)obj);
|
|
}
|
|
else if (t == typeof(Vector4))
|
|
{
|
|
Push(L, (Vector4)obj);
|
|
}
|
|
else if (t == typeof(Color))
|
|
{
|
|
Push(L, (Color)obj);
|
|
}
|
|
else if (t == typeof(RaycastHit))
|
|
{
|
|
Push(L, (RaycastHit)obj);
|
|
}
|
|
else if (t == typeof(Touch))
|
|
{
|
|
Push(L, (Touch)obj);
|
|
}
|
|
else if (t == typeof(Ray))
|
|
{
|
|
Push(L, (Ray)obj);
|
|
}
|
|
else if (t == typeof(Bounds))
|
|
{
|
|
Push(L, (Bounds)obj);
|
|
}
|
|
else if (t == typeof(LayerMask))
|
|
{
|
|
PushLayerMask(L, (LayerMask)obj);
|
|
}
|
|
else
|
|
{
|
|
LuaPushVarObject _Push = null;
|
|
|
|
if (VarPushMap.TryGetValue(t, out _Push))
|
|
{
|
|
_Push(L, obj);
|
|
}
|
|
else
|
|
{
|
|
PushStruct(L, obj);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (t.IsArray)
|
|
{
|
|
Push(L, (Array)obj);
|
|
}
|
|
else if(t == typeof(string))
|
|
{
|
|
LuaDLL.lua_pushstring(L, (string)obj);
|
|
}
|
|
else if (obj is LuaBaseRef)
|
|
{
|
|
Push(L, (LuaBaseRef)obj);
|
|
}
|
|
else if (obj is UnityEngine.Object)
|
|
{
|
|
Push(L, (UnityEngine.Object)obj);
|
|
}
|
|
else if (obj is UnityEngine.TrackedReference)
|
|
{
|
|
Push(L, (UnityEngine.TrackedReference)obj);
|
|
}
|
|
else if (obj is Delegate)
|
|
{
|
|
Push(L, (Delegate)obj);
|
|
}
|
|
else if (obj is IEnumerator)
|
|
{
|
|
Push(L, (IEnumerator)obj);
|
|
}
|
|
else if (t == typeof(EventObject))
|
|
{
|
|
Push(L, (EventObject)obj);
|
|
}
|
|
else if (t == monoType)
|
|
{
|
|
Push(L, (Type)obj);
|
|
}
|
|
else
|
|
{
|
|
PushObject(L, obj);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static void SetBack(IntPtr L, int stackPos, object o)
|
|
{
|
|
int udata = LuaDLL.tolua_rawnetobj(L, stackPos);
|
|
ObjectTranslator translator = ObjectTranslator.Get(L);
|
|
|
|
if (udata != -1)
|
|
{
|
|
translator.SetBack(udata, o);
|
|
}
|
|
}
|
|
|
|
public static int Destroy(IntPtr L)
|
|
{
|
|
int udata = LuaDLL.tolua_rawnetobj(L, 1);
|
|
ObjectTranslator translator = ObjectTranslator.Get(L);
|
|
translator.Destroy(udata);
|
|
return 0;
|
|
}
|
|
|
|
public static void CheckArgsCount(IntPtr L, string method, int count)
|
|
{
|
|
int c = LuaDLL.lua_gettop(L);
|
|
|
|
if (c != count)
|
|
{
|
|
throw new LuaException(string.Format("no overload for method '{0}' takes '{1}' arguments", method, c));
|
|
}
|
|
}
|
|
|
|
public static void CheckArgsCount(IntPtr L, int count)
|
|
{
|
|
int c = LuaDLL.lua_gettop(L);
|
|
|
|
if (c != count)
|
|
{
|
|
throw new LuaException(string.Format("no overload for method takes '{0}' arguments", c));
|
|
}
|
|
}
|
|
|
|
public static Delegate CheckDelegate(Type t, IntPtr L, int stackPos)
|
|
{
|
|
LuaTypes luatype = LuaDLL.lua_type(L, stackPos);
|
|
|
|
switch (luatype)
|
|
{
|
|
case LuaTypes.LUA_TNIL:
|
|
return null;
|
|
case LuaTypes.LUA_TFUNCTION:
|
|
LuaFunction func = ToLua.ToLuaFunction(L, stackPos);
|
|
return DelegateFactory.CreateDelegate(t, func);
|
|
case LuaTypes.LUA_TUSERDATA:
|
|
return (Delegate)ToLua.CheckObject(L, stackPos, t);
|
|
default:
|
|
LuaDLL.luaL_typerror(L, stackPos, LuaMisc.GetTypeName(t));
|
|
return null;
|
|
}
|
|
}
|
|
|
|
public static Delegate CheckDelegate<T>(IntPtr L, int stackPos)
|
|
{
|
|
LuaTypes luatype = LuaDLL.lua_type(L, stackPos);
|
|
|
|
switch (luatype)
|
|
{
|
|
case LuaTypes.LUA_TNIL:
|
|
return null;
|
|
case LuaTypes.LUA_TFUNCTION:
|
|
LuaFunction func = ToLua.ToLuaFunction(L, stackPos);
|
|
return DelegateTraits<T>.Create(func);
|
|
case LuaTypes.LUA_TUSERDATA:
|
|
return (Delegate)ToLua.CheckObject(L, stackPos, typeof(T));
|
|
default:
|
|
LuaDLL.luaL_typerror(L, stackPos, TypeTraits<T>.GetTypeName());
|
|
return null;
|
|
}
|
|
}
|
|
}
|
|
} |