1216 lines
32 KiB
C#
1216 lines
32 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.Runtime.InteropServices;
|
|
using System.Collections;
|
|
|
|
namespace LuaInterface
|
|
{
|
|
public class LuaStackOp
|
|
{
|
|
public sbyte ToSByte(IntPtr L, int stackPos)
|
|
{
|
|
double ret = LuaDLL.lua_tonumber(L, stackPos);
|
|
return Convert.ToSByte(ret);
|
|
}
|
|
|
|
public byte ToByte(IntPtr L, int stackPos)
|
|
{
|
|
double ret = LuaDLL.lua_tonumber(L, stackPos);
|
|
return Convert.ToByte(ret);
|
|
}
|
|
|
|
public short ToInt16(IntPtr L, int stackPos)
|
|
{
|
|
double ret = LuaDLL.lua_tonumber(L, stackPos);
|
|
return Convert.ToInt16(ret);
|
|
}
|
|
|
|
public ushort ToUInt16(IntPtr L, int stackPos)
|
|
{
|
|
double ret = LuaDLL.lua_tonumber(L, stackPos);
|
|
return Convert.ToUInt16(ret);
|
|
}
|
|
|
|
public char ToChar(IntPtr L, int stackPos)
|
|
{
|
|
double ret = LuaDLL.lua_tonumber(L, stackPos);
|
|
return Convert.ToChar(ret);
|
|
}
|
|
|
|
public int ToInt32(IntPtr L, int stackPos)
|
|
{
|
|
double ret = LuaDLL.lua_tonumber(L, stackPos);
|
|
return Convert.ToInt32(ret);
|
|
}
|
|
|
|
public uint ToUInt32(IntPtr L, int stackPos)
|
|
{
|
|
double ret = LuaDLL.lua_tonumber(L, stackPos);
|
|
return Convert.ToUInt32(ret);
|
|
}
|
|
|
|
public decimal ToDecimal(IntPtr L, int stackPos)
|
|
{
|
|
double ret = LuaDLL.lua_tonumber(L, stackPos);
|
|
return Convert.ToDecimal(ret);
|
|
}
|
|
|
|
public float ToFloat(IntPtr L, int stackPos)
|
|
{
|
|
double ret = LuaDLL.lua_tonumber(L, stackPos);
|
|
return Convert.ToSingle(ret);
|
|
}
|
|
|
|
public LuaByteBuffer ToLuaByteBuffer(IntPtr L, int stackPos)
|
|
{
|
|
return new LuaByteBuffer(ToLua.ToByteBuffer(L, stackPos));
|
|
}
|
|
|
|
public IEnumerator ToIter(IntPtr L, int stackPos)
|
|
{
|
|
return (IEnumerator)ToLua.ToObject(L, stackPos);
|
|
}
|
|
|
|
public Type ToType(IntPtr L, int stackPos)
|
|
{
|
|
return (Type)ToLua.ToObject(L, stackPos);
|
|
}
|
|
|
|
public EventObject ToEventObject(IntPtr L, int stackPos)
|
|
{
|
|
return (EventObject)ToLua.ToObject(L, stackPos);
|
|
}
|
|
|
|
public Transform ToTransform(IntPtr L, int stackPos)
|
|
{
|
|
return (Transform)ToLua.ToObject(L, stackPos);
|
|
}
|
|
|
|
public GameObject ToGameObject(IntPtr L, int stackPos)
|
|
{
|
|
return (GameObject)ToLua.ToObject(L, stackPos);
|
|
}
|
|
|
|
public object ToObject(IntPtr L, int stackPos)
|
|
{
|
|
return ToLua.ToObject(L, stackPos);
|
|
}
|
|
|
|
public sbyte CheckSByte(IntPtr L, int stackPos)
|
|
{
|
|
double ret = LuaDLL.luaL_checknumber(L, stackPos);
|
|
return Convert.ToSByte(ret);
|
|
}
|
|
|
|
public byte CheckByte(IntPtr L, int stackPos)
|
|
{
|
|
double ret = LuaDLL.luaL_checknumber(L, stackPos);
|
|
return Convert.ToByte(ret);
|
|
}
|
|
|
|
public short CheckInt16(IntPtr L, int stackPos)
|
|
{
|
|
double ret = LuaDLL.luaL_checknumber(L, stackPos);
|
|
return Convert.ToInt16(ret);
|
|
}
|
|
|
|
public ushort CheckUInt16(IntPtr L, int stackPos)
|
|
{
|
|
double ret = LuaDLL.luaL_checknumber(L, stackPos);
|
|
return Convert.ToUInt16(ret);
|
|
}
|
|
|
|
public char CheckChar(IntPtr L, int stackPos)
|
|
{
|
|
double ret = LuaDLL.luaL_checknumber(L, stackPos);
|
|
return Convert.ToChar(ret);
|
|
}
|
|
|
|
public int CheckInt32(IntPtr L, int stackPos)
|
|
{
|
|
double ret = LuaDLL.luaL_checknumber(L, stackPos);
|
|
return Convert.ToInt32(ret);
|
|
}
|
|
|
|
public uint CheckUInt32(IntPtr L, int stackPos)
|
|
{
|
|
double ret = LuaDLL.luaL_checknumber(L, stackPos);
|
|
return Convert.ToUInt32(ret);
|
|
}
|
|
|
|
public decimal CheckDecimal(IntPtr L, int stackPos)
|
|
{
|
|
double ret = LuaDLL.luaL_checknumber(L, stackPos);
|
|
return Convert.ToDecimal(ret);
|
|
}
|
|
|
|
public float CheckFloat(IntPtr L, int stackPos)
|
|
{
|
|
double ret = LuaDLL.luaL_checknumber(L, stackPos);
|
|
return Convert.ToSingle(ret);
|
|
}
|
|
|
|
public 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;
|
|
}
|
|
}
|
|
|
|
public UIntPtr CheckUIntPtr(IntPtr L, int stackPos)
|
|
{
|
|
throw new LuaException("NYI");
|
|
}
|
|
|
|
public LuaByteBuffer CheckLuaByteBuffer(IntPtr L, int stackPos)
|
|
{
|
|
return new LuaByteBuffer(ToLua.CheckByteBuffer(L, stackPos));
|
|
}
|
|
|
|
public EventObject CheckEventObject(IntPtr L, int stackPos)
|
|
{
|
|
return (EventObject)ToLua.CheckObject(L, stackPos, typeof(EventObject));
|
|
}
|
|
|
|
public Transform CheckTransform(IntPtr L, int stackPos)
|
|
{
|
|
return (Transform)ToLua.CheckObject(L, stackPos, typeof(Transform));
|
|
}
|
|
|
|
public GameObject CheckGameObject(IntPtr L, int stackPos)
|
|
{
|
|
return (GameObject)ToLua.CheckObject(L, stackPos, typeof(GameObject));
|
|
}
|
|
|
|
public void Push(IntPtr L, sbyte n)
|
|
{
|
|
LuaDLL.lua_pushnumber(L, n);
|
|
}
|
|
|
|
public void Push(IntPtr L, byte n)
|
|
{
|
|
LuaDLL.lua_pushnumber(L, n);
|
|
}
|
|
|
|
public void Push(IntPtr L, short n)
|
|
{
|
|
LuaDLL.lua_pushnumber(L, n);
|
|
}
|
|
|
|
public void Push(IntPtr L, ushort n)
|
|
{
|
|
LuaDLL.lua_pushnumber(L, n);
|
|
}
|
|
|
|
public void Push(IntPtr L, char n)
|
|
{
|
|
LuaDLL.lua_pushnumber(L, n);
|
|
}
|
|
|
|
public void Push(IntPtr L, int n)
|
|
{
|
|
LuaDLL.lua_pushnumber(L, n);
|
|
}
|
|
|
|
public void Push(IntPtr L, uint n)
|
|
{
|
|
LuaDLL.lua_pushnumber(L, n);
|
|
}
|
|
|
|
public void Push(IntPtr L, decimal n)
|
|
{
|
|
LuaDLL.lua_pushnumber(L, (double)n);
|
|
}
|
|
|
|
public void Push(IntPtr L, float n)
|
|
{
|
|
LuaDLL.lua_pushnumber(L, n);
|
|
}
|
|
|
|
public void Push(IntPtr L, UIntPtr p)
|
|
{
|
|
throw new LuaException("NYI");
|
|
}
|
|
|
|
public void Push(IntPtr L, Delegate ev)
|
|
{
|
|
ToLua.Push(L, ev);
|
|
}
|
|
|
|
public void Push(IntPtr L, object obj)
|
|
{
|
|
ToLua.Push(L, obj);
|
|
}
|
|
|
|
public void Push(IntPtr L, GameObject o)
|
|
{
|
|
if (o == null)
|
|
{
|
|
LuaDLL.lua_pushnil(L);
|
|
}
|
|
else
|
|
{
|
|
int reference = TypeTraits<GameObject>.GetLuaReference(L);
|
|
|
|
if (reference <= 0)
|
|
{
|
|
reference = ToLua.LoadPreType(L, typeof(GameObject));
|
|
}
|
|
|
|
ToLua.PushUserData(L, o, reference);
|
|
}
|
|
}
|
|
|
|
public void Push(IntPtr L, Transform o)
|
|
{
|
|
if (o == null)
|
|
{
|
|
LuaDLL.lua_pushnil(L);
|
|
}
|
|
else
|
|
{
|
|
Type type = o.GetType();
|
|
int reference = -1;
|
|
|
|
if (type == typeof(Transform))
|
|
{
|
|
reference = TypeTraits<Transform>.GetLuaReference(L);
|
|
}
|
|
else
|
|
{
|
|
reference = LuaStatic.GetMetaReference(L, type);
|
|
}
|
|
|
|
if (reference <= 0)
|
|
{
|
|
reference = ToLua.LoadPreType(L, type);
|
|
}
|
|
|
|
ToLua.PushUserData(L, o, reference);
|
|
}
|
|
}
|
|
|
|
#region Nullable
|
|
public Nullable<sbyte> ToNullSByte(IntPtr L, int stackPos)
|
|
{
|
|
if (LuaDLL.lua_type(L, stackPos) == LuaTypes.LUA_TNIL)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
double ret = LuaDLL.lua_tonumber(L, stackPos);
|
|
return Convert.ToSByte(ret);
|
|
}
|
|
|
|
public Nullable<byte> ToNullByte(IntPtr L, int stackPos)
|
|
{
|
|
if (LuaDLL.lua_type(L, stackPos) == LuaTypes.LUA_TNIL)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
double ret = LuaDLL.lua_tonumber(L, stackPos);
|
|
return Convert.ToByte(ret);
|
|
}
|
|
|
|
public Nullable<short> ToNullInt16(IntPtr L, int stackPos)
|
|
{
|
|
if (LuaDLL.lua_type(L, stackPos) == LuaTypes.LUA_TNIL)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
double ret = LuaDLL.lua_tonumber(L, stackPos);
|
|
return Convert.ToInt16(ret);
|
|
}
|
|
|
|
public Nullable<ushort> ToNullUInt16(IntPtr L, int stackPos)
|
|
{
|
|
if (LuaDLL.lua_type(L, stackPos) == LuaTypes.LUA_TNIL)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
double ret = LuaDLL.lua_tonumber(L, stackPos);
|
|
return Convert.ToUInt16(ret);
|
|
}
|
|
|
|
public Nullable<char> ToNullChar(IntPtr L, int stackPos)
|
|
{
|
|
if (LuaDLL.lua_type(L, stackPos) == LuaTypes.LUA_TNIL)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
double ret = LuaDLL.lua_tonumber(L, stackPos);
|
|
return Convert.ToChar(ret);
|
|
}
|
|
|
|
public Nullable<int> ToNullInt32(IntPtr L, int stackPos)
|
|
{
|
|
if (LuaDLL.lua_type(L, stackPos) == LuaTypes.LUA_TNIL)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
double ret = LuaDLL.lua_tonumber(L, stackPos);
|
|
return Convert.ToInt32(ret);
|
|
}
|
|
|
|
public Nullable<uint> ToNullUInt32(IntPtr L, int stackPos)
|
|
{
|
|
if (LuaDLL.lua_type(L, stackPos) == LuaTypes.LUA_TNIL)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
double ret = LuaDLL.lua_tonumber(L, stackPos);
|
|
return Convert.ToUInt32(ret);
|
|
}
|
|
|
|
public Nullable<decimal> ToNullDecimal(IntPtr L, int stackPos)
|
|
{
|
|
if (LuaDLL.lua_type(L, stackPos) == LuaTypes.LUA_TNIL)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
double ret = LuaDLL.lua_tonumber(L, stackPos);
|
|
return Convert.ToDecimal(ret);
|
|
}
|
|
|
|
public Nullable<float> ToNullFloat(IntPtr L, int stackPos)
|
|
{
|
|
if (LuaDLL.lua_type(L, stackPos) == LuaTypes.LUA_TNIL)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
double ret = LuaDLL.lua_tonumber(L, stackPos);
|
|
return Convert.ToSingle(ret);
|
|
}
|
|
|
|
public Nullable<double> ToNullNumber(IntPtr L, int stackPos)
|
|
{
|
|
if (LuaDLL.lua_type(L, stackPos) == LuaTypes.LUA_TNIL)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
return LuaDLL.lua_tonumber(L, stackPos);
|
|
}
|
|
|
|
public Nullable<bool> ToNullBool(IntPtr L, int stackPos)
|
|
{
|
|
if (LuaDLL.lua_type(L, stackPos) == LuaTypes.LUA_TNIL)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
return LuaDLL.lua_toboolean(L, stackPos);
|
|
}
|
|
|
|
public Nullable<long> ToNullInt64(IntPtr L, int stackPos)
|
|
{
|
|
if (LuaDLL.lua_type(L, stackPos) == LuaTypes.LUA_TNIL)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
return LuaDLL.tolua_toint64(L, stackPos);
|
|
}
|
|
|
|
public Nullable<ulong> ToNullUInt64(IntPtr L, int stackPos)
|
|
{
|
|
if (LuaDLL.lua_type(L, stackPos) == LuaTypes.LUA_TNIL)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
return LuaDLL.tolua_touint64(L, stackPos);
|
|
}
|
|
|
|
public sbyte[] ToSByteArray(IntPtr L, int stackPos)
|
|
{
|
|
return ToLua.ToNumberArray<sbyte>(L, stackPos);
|
|
}
|
|
|
|
public short[] ToInt16Array(IntPtr L, int stackPos)
|
|
{
|
|
return ToLua.ToNumberArray<short>(L, stackPos);
|
|
}
|
|
|
|
public ushort[] ToUInt16Array(IntPtr L, int stackPos)
|
|
{
|
|
return ToLua.ToNumberArray<ushort>(L, stackPos);
|
|
}
|
|
|
|
public decimal[] ToDecimalArray(IntPtr L, int stackPos)
|
|
{
|
|
return ToLua.ToNumberArray<decimal>(L, stackPos);
|
|
}
|
|
|
|
public float[] ToFloatArray(IntPtr L, int stackPos)
|
|
{
|
|
return ToLua.ToNumberArray<float>(L, stackPos);
|
|
}
|
|
|
|
public double[] ToDoubleArray(IntPtr L, int stackPos)
|
|
{
|
|
return ToLua.ToNumberArray<double>(L, stackPos);
|
|
}
|
|
|
|
public int[] ToInt32Array(IntPtr L, int stackPos)
|
|
{
|
|
return ToLua.ToNumberArray<int>(L, stackPos);
|
|
}
|
|
|
|
public uint[] ToUInt32Array(IntPtr L, int stackPos)
|
|
{
|
|
return ToLua.ToNumberArray<uint>(L, stackPos);
|
|
}
|
|
|
|
public long[] ToInt64Array(IntPtr L, int stackPos)
|
|
{
|
|
return ToLua.ToStructArray<long>(L, stackPos);
|
|
}
|
|
|
|
public ulong[] ToUInt64Array(IntPtr L, int stackPos)
|
|
{
|
|
return ToLua.ToStructArray<ulong>(L, stackPos);
|
|
}
|
|
|
|
public Nullable<Vector3> ToNullVec3(IntPtr L, int stackPos)
|
|
{
|
|
if (LuaDLL.lua_type(L, stackPos) == LuaTypes.LUA_TNIL)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
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 Nullable<Quaternion> ToNullQuat(IntPtr L, int stackPos)
|
|
{
|
|
if (LuaDLL.lua_type(L, stackPos) == LuaTypes.LUA_TNIL)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
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 Nullable<Vector2> ToNullVec2(IntPtr L, int stackPos)
|
|
{
|
|
if (LuaDLL.lua_type(L, stackPos) == LuaTypes.LUA_TNIL)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
float x, y;
|
|
LuaDLL.tolua_getvec2(L, stackPos, out x, out y);
|
|
return new Vector2(x, y);
|
|
}
|
|
|
|
public Nullable<Color> ToNullColor(IntPtr L, int stackPos)
|
|
{
|
|
if (LuaDLL.lua_type(L, stackPos) == LuaTypes.LUA_TNIL)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
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 Nullable<Vector4> ToNullVec4(IntPtr L, int stackPos)
|
|
{
|
|
if (LuaDLL.lua_type(L, stackPos) == LuaTypes.LUA_TNIL)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
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 Nullable<Ray> ToNullRay(IntPtr L, int stackPos)
|
|
{
|
|
if (LuaDLL.lua_type(L, stackPos) == LuaTypes.LUA_TNIL)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
return ToLua.ToRay(L, stackPos);
|
|
}
|
|
|
|
public Nullable<Bounds> ToNullBounds(IntPtr L, int stackPos)
|
|
{
|
|
if (LuaDLL.lua_type(L, stackPos) == LuaTypes.LUA_TNIL)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
return ToLua.ToBounds(L, stackPos);
|
|
}
|
|
|
|
public Nullable<LayerMask> ToNullLayerMask(IntPtr L, int stackPos)
|
|
{
|
|
if (LuaDLL.lua_type(L, stackPos) == LuaTypes.LUA_TNIL)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
return LuaDLL.tolua_getlayermask(L, stackPos);
|
|
}
|
|
|
|
public Vector3[] ToVec3Array(IntPtr L, int stackPos)
|
|
{
|
|
return ToLua.ToStructArray<Vector3>(L, stackPos);
|
|
}
|
|
|
|
public Quaternion[] ToQuatArray(IntPtr L, int stackPos)
|
|
{
|
|
return ToLua.ToStructArray<Quaternion>(L, stackPos);
|
|
}
|
|
|
|
public Vector2[] ToVec2Array(IntPtr L, int stackPos)
|
|
{
|
|
return ToLua.ToStructArray<Vector2>(L, stackPos);
|
|
}
|
|
|
|
public Color[] ToColorArray(IntPtr L, int stackPos)
|
|
{
|
|
return ToLua.ToStructArray<Color>(L, stackPos);
|
|
}
|
|
|
|
public Vector4[] ToVec4Array(IntPtr L, int stackPos)
|
|
{
|
|
return ToLua.ToStructArray<Vector4>(L, stackPos);
|
|
}
|
|
|
|
public Type[] ToTypeArray(IntPtr L, int stackPos)
|
|
{
|
|
return ToLua.ToObjectArray<Type>(L, stackPos);
|
|
}
|
|
|
|
public Nullable<sbyte> CheckNullSByte(IntPtr L, int stackPos)
|
|
{
|
|
if (LuaDLL.lua_type(L, stackPos) == LuaTypes.LUA_TNIL)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
double ret = LuaDLL.luaL_checknumber(L, stackPos);
|
|
return Convert.ToSByte(ret);
|
|
}
|
|
|
|
public Nullable<byte> CheckNullByte(IntPtr L, int stackPos)
|
|
{
|
|
if (LuaDLL.lua_type(L, stackPos) == LuaTypes.LUA_TNIL)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
double ret = LuaDLL.luaL_checknumber(L, stackPos);
|
|
return Convert.ToByte(ret);
|
|
}
|
|
|
|
public Nullable<short> CheckNullInt16(IntPtr L, int stackPos)
|
|
{
|
|
if (LuaDLL.lua_type(L, stackPos) == LuaTypes.LUA_TNIL)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
double ret = LuaDLL.luaL_checknumber(L, stackPos);
|
|
return Convert.ToInt16(ret);
|
|
}
|
|
|
|
public Nullable<ushort> CheckNullUInt16(IntPtr L, int stackPos)
|
|
{
|
|
if (LuaDLL.lua_type(L, stackPos) == LuaTypes.LUA_TNIL)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
double ret = LuaDLL.luaL_checknumber(L, stackPos);
|
|
return Convert.ToUInt16(ret);
|
|
}
|
|
|
|
public Nullable<char> CheckNullChar(IntPtr L, int stackPos)
|
|
{
|
|
if (LuaDLL.lua_type(L, stackPos) == LuaTypes.LUA_TNIL)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
double ret = LuaDLL.luaL_checknumber(L, stackPos);
|
|
return Convert.ToChar(ret);
|
|
}
|
|
|
|
public Nullable<int> CheckNullInt32(IntPtr L, int stackPos)
|
|
{
|
|
if (LuaDLL.lua_type(L, stackPos) == LuaTypes.LUA_TNIL)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
double ret = LuaDLL.luaL_checknumber(L, stackPos);
|
|
return Convert.ToInt32(ret);
|
|
}
|
|
|
|
public Nullable<uint> CheckNullUInt32(IntPtr L, int stackPos)
|
|
{
|
|
if (LuaDLL.lua_type(L, stackPos) == LuaTypes.LUA_TNIL)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
double ret = LuaDLL.luaL_checknumber(L, stackPos);
|
|
return Convert.ToUInt32(ret);
|
|
}
|
|
|
|
public Nullable<decimal> CheckNullDecimal(IntPtr L, int stackPos)
|
|
{
|
|
if (LuaDLL.lua_type(L, stackPos) == LuaTypes.LUA_TNIL)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
double ret = LuaDLL.luaL_checknumber(L, stackPos);
|
|
return Convert.ToDecimal(ret);
|
|
}
|
|
|
|
public Nullable<float> CheckNullFloat(IntPtr L, int stackPos)
|
|
{
|
|
if (LuaDLL.lua_type(L, stackPos) == LuaTypes.LUA_TNIL)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
double ret = LuaDLL.luaL_checknumber(L, stackPos);
|
|
return Convert.ToSingle(ret);
|
|
}
|
|
|
|
public Nullable<double> CheckNullNumber(IntPtr L, int stackPos)
|
|
{
|
|
if (LuaDLL.lua_type(L, stackPos) == LuaTypes.LUA_TNIL)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
return LuaDLL.luaL_checknumber(L, stackPos);
|
|
}
|
|
|
|
public Nullable<bool> CheckNullBool(IntPtr L, int stackPos)
|
|
{
|
|
if (LuaDLL.lua_type(L, stackPos) == LuaTypes.LUA_TNIL)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
return LuaDLL.luaL_checkboolean(L, stackPos);
|
|
}
|
|
|
|
public Nullable<long> CheckNullInt64(IntPtr L, int stackPos)
|
|
{
|
|
if (LuaDLL.lua_type(L, stackPos) == LuaTypes.LUA_TNIL)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
return LuaDLL.tolua_checkint64(L, stackPos);
|
|
}
|
|
|
|
public Nullable<ulong> CheckNullUInt64(IntPtr L, int stackPos)
|
|
{
|
|
if (LuaDLL.lua_type(L, stackPos) == LuaTypes.LUA_TNIL)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
return LuaDLL.tolua_checkuint64(L, stackPos);
|
|
}
|
|
|
|
public sbyte[] CheckSByteArray(IntPtr L, int stackPos)
|
|
{
|
|
return ToLua.CheckNumberArray<sbyte>(L, stackPos);
|
|
}
|
|
|
|
public short[] CheckInt16Array(IntPtr L, int stackPos)
|
|
{
|
|
return ToLua.CheckNumberArray<short>(L, stackPos);
|
|
}
|
|
|
|
public ushort[] CheckUInt16Array(IntPtr L, int stackPos)
|
|
{
|
|
return ToLua.CheckNumberArray<ushort>(L, stackPos);
|
|
}
|
|
|
|
public decimal[] CheckDecimalArray(IntPtr L, int stackPos)
|
|
{
|
|
return ToLua.CheckNumberArray<decimal>(L, stackPos);
|
|
}
|
|
|
|
public float[] CheckFloatArray(IntPtr L, int stackPos)
|
|
{
|
|
return ToLua.CheckNumberArray<float>(L, stackPos);
|
|
}
|
|
|
|
public double[] CheckDoubleArray(IntPtr L, int stackPos)
|
|
{
|
|
return ToLua.CheckNumberArray<double>(L, stackPos);
|
|
}
|
|
|
|
public int[] CheckInt32Array(IntPtr L, int stackPos)
|
|
{
|
|
return ToLua.CheckNumberArray<int>(L, stackPos);
|
|
}
|
|
|
|
public uint[] CheckUInt32Array(IntPtr L, int stackPos)
|
|
{
|
|
return ToLua.CheckNumberArray<uint>(L, stackPos);
|
|
}
|
|
|
|
public long[] CheckInt64Array(IntPtr L, int stackPos)
|
|
{
|
|
return ToLua.CheckStructArray<long>(L, stackPos);
|
|
}
|
|
|
|
public ulong[] CheckUInt64Array(IntPtr L, int stackPos)
|
|
{
|
|
return ToLua.CheckStructArray<ulong>(L, stackPos);
|
|
}
|
|
|
|
public Nullable<Vector3> CheckNullVec3(IntPtr L, int stackPos)
|
|
{
|
|
if (LuaDLL.lua_type(L, stackPos) == LuaTypes.LUA_TNIL)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
return ToLua.CheckVector3(L, stackPos);
|
|
}
|
|
|
|
public Nullable<Quaternion> CheckNullQuat(IntPtr L, int stackPos)
|
|
{
|
|
if (LuaDLL.lua_type(L, stackPos) == LuaTypes.LUA_TNIL)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
return ToLua.CheckQuaternion(L, stackPos);
|
|
}
|
|
|
|
public Nullable<Vector2> CheckNullVec2(IntPtr L, int stackPos)
|
|
{
|
|
if (LuaDLL.lua_type(L, stackPos) == LuaTypes.LUA_TNIL)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
return ToLua.CheckVector2(L, stackPos);
|
|
}
|
|
|
|
public Nullable<Color> CheckNullColor(IntPtr L, int stackPos)
|
|
{
|
|
if (LuaDLL.lua_type(L, stackPos) == LuaTypes.LUA_TNIL)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
return ToLua.CheckColor(L, stackPos);
|
|
}
|
|
|
|
public Nullable<Vector4> CheckNullVec4(IntPtr L, int stackPos)
|
|
{
|
|
if (LuaDLL.lua_type(L, stackPos) == LuaTypes.LUA_TNIL)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
return ToLua.CheckVector4(L, stackPos);
|
|
}
|
|
|
|
public Nullable<Ray> CheckNullRay(IntPtr L, int stackPos)
|
|
{
|
|
if (LuaDLL.lua_type(L, stackPos) == LuaTypes.LUA_TNIL)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
return ToLua.CheckRay(L, stackPos);
|
|
}
|
|
|
|
public Nullable<Bounds> CheckNullBounds(IntPtr L, int stackPos)
|
|
{
|
|
if (LuaDLL.lua_type(L, stackPos) == LuaTypes.LUA_TNIL)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
return ToLua.CheckBounds(L, stackPos);
|
|
}
|
|
|
|
public Nullable<LayerMask> CheckNullLayerMask(IntPtr L, int stackPos)
|
|
{
|
|
if (LuaDLL.lua_type(L, stackPos) == LuaTypes.LUA_TNIL)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
return ToLua.CheckLayerMask(L, stackPos);
|
|
}
|
|
|
|
public Vector3[] CheckVec3Array(IntPtr L, int stackPos)
|
|
{
|
|
return ToLua.CheckStructArray<Vector3>(L, stackPos);
|
|
}
|
|
|
|
public Quaternion[] CheckQuatArray(IntPtr L, int stackPos)
|
|
{
|
|
return ToLua.CheckStructArray<Quaternion>(L, stackPos);
|
|
}
|
|
|
|
public Vector2[] CheckVec2Array(IntPtr L, int stackPos)
|
|
{
|
|
return ToLua.CheckStructArray<Vector2>(L, stackPos);
|
|
}
|
|
|
|
public Color[] CheckColorArray(IntPtr L, int stackPos)
|
|
{
|
|
return ToLua.CheckStructArray<Color>(L, stackPos);
|
|
}
|
|
|
|
public Vector4[] CheckVec4Array(IntPtr L, int stackPos)
|
|
{
|
|
return ToLua.CheckStructArray<Vector4>(L, stackPos);
|
|
}
|
|
|
|
public Type[] CheckTypeArray(IntPtr L, int stackPos)
|
|
{
|
|
return ToLua.CheckObjectArray<Type>(L, stackPos);
|
|
}
|
|
|
|
public void Push(IntPtr L, Nullable<sbyte> n)
|
|
{
|
|
if (n == null)
|
|
{
|
|
LuaDLL.lua_pushnil(L);
|
|
}
|
|
else
|
|
{
|
|
LuaDLL.lua_pushnumber(L, n.Value);
|
|
}
|
|
}
|
|
|
|
public void Push(IntPtr L, Nullable<byte> n)
|
|
{
|
|
if (n == null)
|
|
{
|
|
LuaDLL.lua_pushnil(L);
|
|
}
|
|
else
|
|
{
|
|
LuaDLL.lua_pushnumber(L, n.Value);
|
|
}
|
|
}
|
|
|
|
public void Push(IntPtr L, Nullable<short> n)
|
|
{
|
|
if (n == null)
|
|
{
|
|
LuaDLL.lua_pushnil(L);
|
|
}
|
|
else
|
|
{
|
|
LuaDLL.lua_pushnumber(L, n.Value);
|
|
}
|
|
}
|
|
|
|
public void Push(IntPtr L, Nullable<ushort> n)
|
|
{
|
|
if (n == null)
|
|
{
|
|
LuaDLL.lua_pushnil(L);
|
|
}
|
|
else
|
|
{
|
|
LuaDLL.lua_pushnumber(L, n.Value);
|
|
}
|
|
}
|
|
|
|
public void Push(IntPtr L, Nullable<char> n)
|
|
{
|
|
if (n == null)
|
|
{
|
|
LuaDLL.lua_pushnil(L);
|
|
}
|
|
else
|
|
{
|
|
LuaDLL.lua_pushnumber(L, n.Value);
|
|
}
|
|
}
|
|
|
|
public void Push(IntPtr L, Nullable<int> n)
|
|
{
|
|
if (n == null)
|
|
{
|
|
LuaDLL.lua_pushnil(L);
|
|
}
|
|
else
|
|
{
|
|
LuaDLL.lua_pushnumber(L, n.Value);
|
|
}
|
|
}
|
|
|
|
public void Push(IntPtr L, Nullable<uint> n)
|
|
{
|
|
if (n == null)
|
|
{
|
|
LuaDLL.lua_pushnil(L);
|
|
}
|
|
else
|
|
{
|
|
LuaDLL.lua_pushnumber(L, n.Value);
|
|
}
|
|
}
|
|
|
|
public void Push(IntPtr L, Nullable<decimal> n)
|
|
{
|
|
if (n == null)
|
|
{
|
|
LuaDLL.lua_pushnil(L);
|
|
}
|
|
else
|
|
{
|
|
LuaDLL.lua_pushnumber(L, Convert.ToDouble(n.Value));
|
|
}
|
|
}
|
|
|
|
public void Push(IntPtr L, Nullable<float> n)
|
|
{
|
|
if (n == null)
|
|
{
|
|
LuaDLL.lua_pushnil(L);
|
|
}
|
|
else
|
|
{
|
|
LuaDLL.lua_pushnumber(L, n.Value);
|
|
}
|
|
}
|
|
|
|
public void Push(IntPtr L, Nullable<double> n)
|
|
{
|
|
if (n == null)
|
|
{
|
|
LuaDLL.lua_pushnil(L);
|
|
}
|
|
else
|
|
{
|
|
LuaDLL.lua_pushnumber(L, n.Value);
|
|
}
|
|
}
|
|
|
|
public void Push(IntPtr L, Nullable<bool> n)
|
|
{
|
|
if (n == null)
|
|
{
|
|
LuaDLL.lua_pushnil(L);
|
|
}
|
|
else
|
|
{
|
|
LuaDLL.lua_pushboolean(L, n.Value);
|
|
}
|
|
}
|
|
|
|
public void Push(IntPtr L, Nullable<long> n)
|
|
{
|
|
if (n == null)
|
|
{
|
|
LuaDLL.lua_pushnil(L);
|
|
}
|
|
else
|
|
{
|
|
LuaDLL.tolua_pushint64(L, n.Value);
|
|
}
|
|
}
|
|
|
|
public void Push(IntPtr L, Nullable<ulong> n)
|
|
{
|
|
if (n == null)
|
|
{
|
|
LuaDLL.lua_pushnil(L);
|
|
}
|
|
else
|
|
{
|
|
LuaDLL.tolua_pushuint64(L, n.Value);
|
|
}
|
|
}
|
|
|
|
public void Push(IntPtr L, Nullable<Vector3> v3)
|
|
{
|
|
if (v3 == null)
|
|
{
|
|
LuaDLL.lua_pushnil(L);
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
Vector3 v = v3.Value;
|
|
LuaDLL.tolua_pushvec3(L, v.x, v.y, v.z);
|
|
}
|
|
}
|
|
|
|
public void Push(IntPtr L, Nullable<Quaternion> n)
|
|
{
|
|
if (n == null)
|
|
{
|
|
LuaDLL.lua_pushnil(L);
|
|
}
|
|
else
|
|
{
|
|
Quaternion q = n.Value;
|
|
LuaDLL.tolua_pushquat(L, q.x, q.y, q.z, q.w);
|
|
}
|
|
}
|
|
|
|
public void Push(IntPtr L, Nullable<Vector2> n)
|
|
{
|
|
if (n == null)
|
|
{
|
|
LuaDLL.lua_pushnil(L);
|
|
}
|
|
else
|
|
{
|
|
Vector2 v2 = n.Value;
|
|
LuaDLL.tolua_pushvec2(L, v2.x, v2.y);
|
|
}
|
|
}
|
|
|
|
public void Push(IntPtr L, Nullable<Color> n)
|
|
{
|
|
if (n == null)
|
|
{
|
|
LuaDLL.lua_pushnil(L);
|
|
}
|
|
else
|
|
{
|
|
Color clr = n.Value;
|
|
LuaDLL.tolua_pushclr(L, clr.r, clr.g, clr.b, clr.a);
|
|
}
|
|
}
|
|
|
|
public void Push(IntPtr L, Nullable<Vector4> n)
|
|
{
|
|
if (n == null)
|
|
{
|
|
LuaDLL.lua_pushnil(L);
|
|
}
|
|
else
|
|
{
|
|
Vector4 v4 = n.Value;
|
|
LuaDLL.tolua_pushvec4(L, v4.x, v4.y, v4.z, v4.w);
|
|
}
|
|
}
|
|
|
|
public void Push(IntPtr L, Nullable<Ray> n)
|
|
{
|
|
if (n == null)
|
|
{
|
|
LuaDLL.lua_pushnil(L);
|
|
}
|
|
else
|
|
{
|
|
ToLua.Push(L, n.Value);
|
|
}
|
|
}
|
|
|
|
public void Push(IntPtr L, Nullable<Bounds> n)
|
|
{
|
|
if (n == null)
|
|
{
|
|
LuaDLL.lua_pushnil(L);
|
|
}
|
|
else
|
|
{
|
|
ToLua.Push(L, n.Value);
|
|
}
|
|
}
|
|
|
|
public void Push(IntPtr L, Nullable<LayerMask> n)
|
|
{
|
|
if (n == null)
|
|
{
|
|
LuaDLL.lua_pushnil(L);
|
|
}
|
|
else
|
|
{
|
|
LuaDLL.tolua_pushlayermask(L, n.Value);
|
|
}
|
|
}
|
|
|
|
public void Push(IntPtr L, Nullable<Touch> n)
|
|
{
|
|
if (n == null)
|
|
{
|
|
LuaDLL.lua_pushnil(L);
|
|
}
|
|
else
|
|
{
|
|
ToLua.Push(L, n.Value);
|
|
}
|
|
}
|
|
|
|
public void Push(IntPtr L, Nullable<RaycastHit> n)
|
|
{
|
|
if (n == null)
|
|
{
|
|
LuaDLL.lua_pushnil(L);
|
|
}
|
|
else
|
|
{
|
|
ToLua.Push(L, n.Value);
|
|
}
|
|
}
|
|
#endregion
|
|
}
|
|
}
|