952 lines
		
	
	
		
			22 KiB
		
	
	
	
		
			C#
		
	
			
		
		
	
	
			952 lines
		
	
	
		
			22 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 System;
 | 
						|
using System.Collections.Generic;
 | 
						|
using UnityEngine;
 | 
						|
 | 
						|
namespace LuaInterface
 | 
						|
{
 | 
						|
    public class LuaFunction : LuaBaseRef
 | 
						|
    {
 | 
						|
        protected struct FuncData
 | 
						|
        {
 | 
						|
            public int oldTop;
 | 
						|
            public int stackPos;
 | 
						|
 | 
						|
            public FuncData(int top, int stack)
 | 
						|
            {
 | 
						|
                oldTop = top;
 | 
						|
                stackPos = stack;
 | 
						|
            }
 | 
						|
        }
 | 
						|
 | 
						|
        protected int oldTop = -1;
 | 
						|
        private int argCount = 0;
 | 
						|
        private int stackPos = -1;
 | 
						|
        private Stack<FuncData> stack = new Stack<FuncData>();
 | 
						|
 | 
						|
        public LuaFunction(int reference, LuaState state)
 | 
						|
        {
 | 
						|
            this.reference = reference;
 | 
						|
            this.luaState = state;
 | 
						|
        }
 | 
						|
 | 
						|
        public override void Dispose()
 | 
						|
        {
 | 
						|
#if UNITY_EDITOR
 | 
						|
            if (oldTop != -1 && count <= 1)
 | 
						|
            {
 | 
						|
                Debugger.LogError("You must call EndPCall before calling Dispose");
 | 
						|
            }
 | 
						|
#endif
 | 
						|
            base.Dispose();
 | 
						|
        }
 | 
						|
 | 
						|
        public T ToDelegate<T>() where T : class
 | 
						|
        {
 | 
						|
            return DelegateTraits<T>.Create(this) as T;
 | 
						|
        }
 | 
						|
 | 
						|
        public virtual int BeginPCall()
 | 
						|
        {
 | 
						|
            if (luaState == null)
 | 
						|
            {
 | 
						|
                throw new LuaException("LuaFunction has been disposed");
 | 
						|
            }
 | 
						|
 | 
						|
            stack.Push(new FuncData(oldTop, stackPos));
 | 
						|
            oldTop = luaState.BeginPCall(reference);
 | 
						|
            stackPos = -1;
 | 
						|
            argCount = 0;
 | 
						|
            return oldTop;
 | 
						|
        }
 | 
						|
 | 
						|
        public void PCall()
 | 
						|
        {
 | 
						|
#if UNITY_EDITOR
 | 
						|
            if (oldTop == -1)
 | 
						|
            {
 | 
						|
                Debugger.LogError("You must call BeginPCall before calling PCall");
 | 
						|
            }
 | 
						|
#endif
 | 
						|
 | 
						|
            stackPos = oldTop + 1;
 | 
						|
 | 
						|
            try
 | 
						|
            {
 | 
						|
                luaState.PCall(argCount, oldTop);
 | 
						|
            }
 | 
						|
            catch (Exception e)
 | 
						|
            {
 | 
						|
                EndPCall();
 | 
						|
                throw e;
 | 
						|
            }
 | 
						|
        }
 | 
						|
 | 
						|
        public void EndPCall()
 | 
						|
        {
 | 
						|
            if (oldTop != -1)
 | 
						|
            {
 | 
						|
                luaState.EndPCall(oldTop);
 | 
						|
                argCount = 0;
 | 
						|
                FuncData data = stack.Pop();
 | 
						|
                oldTop = data.oldTop;
 | 
						|
                stackPos = data.stackPos;
 | 
						|
            }
 | 
						|
        }
 | 
						|
 | 
						|
        public void Call()
 | 
						|
        {
 | 
						|
            BeginPCall();
 | 
						|
            PCall();
 | 
						|
            EndPCall();
 | 
						|
        }
 | 
						|
 | 
						|
        public void Call<T1>(T1 arg1)
 | 
						|
        {
 | 
						|
            BeginPCall();
 | 
						|
            PushGeneric(arg1);
 | 
						|
            PCall();
 | 
						|
            EndPCall();
 | 
						|
        }
 | 
						|
 | 
						|
        public void Call<T1, T2>(T1 arg1, T2 arg2)
 | 
						|
        {
 | 
						|
            BeginPCall();
 | 
						|
            PushGeneric(arg1);
 | 
						|
            PushGeneric(arg2);
 | 
						|
            PCall();
 | 
						|
            EndPCall();
 | 
						|
        }
 | 
						|
 | 
						|
        public void Call<T1, T2, T3>(T1 arg1, T2 arg2, T3 arg3)
 | 
						|
        {
 | 
						|
            BeginPCall();
 | 
						|
            PushGeneric(arg1);
 | 
						|
            PushGeneric(arg2);
 | 
						|
            PushGeneric(arg3);
 | 
						|
            PCall();
 | 
						|
            EndPCall();
 | 
						|
        }
 | 
						|
 | 
						|
        public void Call<T1, T2, T3, T4>(T1 arg1, T2 arg2, T3 arg3, T4 arg4)
 | 
						|
        {
 | 
						|
            BeginPCall();
 | 
						|
            PushGeneric(arg1);
 | 
						|
            PushGeneric(arg2);
 | 
						|
            PushGeneric(arg3);
 | 
						|
            PushGeneric(arg4);
 | 
						|
            PCall();
 | 
						|
            EndPCall();
 | 
						|
        }
 | 
						|
 | 
						|
        public void Call<T1, T2, T3, T4, T5>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5)
 | 
						|
        {
 | 
						|
            BeginPCall();
 | 
						|
            PushGeneric(arg1);
 | 
						|
            PushGeneric(arg2);
 | 
						|
            PushGeneric(arg3);
 | 
						|
            PushGeneric(arg4);
 | 
						|
            PushGeneric(arg5);
 | 
						|
            PCall();
 | 
						|
            EndPCall();
 | 
						|
        }
 | 
						|
 | 
						|
        public void Call<T1, T2, T3, T4, T5, T6>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6)
 | 
						|
        {
 | 
						|
            BeginPCall();
 | 
						|
            PushGeneric(arg1);
 | 
						|
            PushGeneric(arg2);
 | 
						|
            PushGeneric(arg3);
 | 
						|
            PushGeneric(arg4);
 | 
						|
            PushGeneric(arg5);
 | 
						|
            PushGeneric(arg6);
 | 
						|
            PCall();
 | 
						|
            EndPCall();
 | 
						|
        }
 | 
						|
 | 
						|
        public void Call<T1, T2, T3, T4, T5, T6, T7>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7)
 | 
						|
        {
 | 
						|
            BeginPCall();
 | 
						|
            PushGeneric(arg1);
 | 
						|
            PushGeneric(arg2);
 | 
						|
            PushGeneric(arg3);
 | 
						|
            PushGeneric(arg4);
 | 
						|
            PushGeneric(arg5);
 | 
						|
            PushGeneric(arg6);
 | 
						|
            PushGeneric(arg7);
 | 
						|
            PCall();
 | 
						|
            EndPCall();
 | 
						|
        }
 | 
						|
 | 
						|
        public void Call<T1, T2, T3, T4, T5, T6, T7, T8>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8)
 | 
						|
        {
 | 
						|
            BeginPCall();
 | 
						|
            PushGeneric(arg1);
 | 
						|
            PushGeneric(arg2);
 | 
						|
            PushGeneric(arg3);
 | 
						|
            PushGeneric(arg4);
 | 
						|
            PushGeneric(arg5);
 | 
						|
            PushGeneric(arg6);
 | 
						|
            PushGeneric(arg7);
 | 
						|
            PushGeneric(arg8);
 | 
						|
            PCall();
 | 
						|
            EndPCall();
 | 
						|
        }
 | 
						|
 | 
						|
        public void Call<T1, T2, T3, T4, T5, T6, T7, T8, T9>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9)
 | 
						|
        {
 | 
						|
            BeginPCall();
 | 
						|
            PushGeneric(arg1);
 | 
						|
            PushGeneric(arg2);
 | 
						|
            PushGeneric(arg3);
 | 
						|
            PushGeneric(arg4);
 | 
						|
            PushGeneric(arg5);
 | 
						|
            PushGeneric(arg6);
 | 
						|
            PushGeneric(arg7);
 | 
						|
            PushGeneric(arg8);
 | 
						|
            PushGeneric(arg9);
 | 
						|
            PCall();
 | 
						|
            EndPCall();
 | 
						|
        }
 | 
						|
 | 
						|
        public R1 Invoke<R1>()
 | 
						|
        {
 | 
						|
            BeginPCall();
 | 
						|
            PCall();
 | 
						|
            R1 ret1 = CheckValue<R1>();
 | 
						|
            EndPCall();
 | 
						|
            return ret1;
 | 
						|
        }
 | 
						|
 | 
						|
        public R1 Invoke<T1, R1>(T1 arg1)
 | 
						|
        {
 | 
						|
            BeginPCall();
 | 
						|
            PushGeneric(arg1);
 | 
						|
            PCall();
 | 
						|
            R1 ret1 = CheckValue<R1>();
 | 
						|
            EndPCall();
 | 
						|
            return ret1;
 | 
						|
        }
 | 
						|
 | 
						|
        public R1 Invoke<T1, T2, R1>(T1 arg1, T2 arg2)
 | 
						|
        {
 | 
						|
            BeginPCall();
 | 
						|
            PushGeneric(arg1);
 | 
						|
            PushGeneric(arg2);
 | 
						|
            PCall();
 | 
						|
            R1 ret1 = CheckValue<R1>();
 | 
						|
            EndPCall();
 | 
						|
            return ret1;
 | 
						|
        }
 | 
						|
 | 
						|
        public R1 Invoke<T1, T2, T3, R1>(T1 arg1, T2 arg2, T3 arg3)
 | 
						|
        {
 | 
						|
            BeginPCall();
 | 
						|
            PushGeneric(arg1);
 | 
						|
            PushGeneric(arg2);
 | 
						|
            PushGeneric(arg3);
 | 
						|
            PCall();
 | 
						|
            R1 ret1 = CheckValue<R1>();
 | 
						|
            EndPCall();
 | 
						|
            return ret1;
 | 
						|
        }
 | 
						|
 | 
						|
        public R1 Invoke<T1, T2, T3, T4, R1>(T1 arg1, T2 arg2, T3 arg3, T4 arg4)
 | 
						|
        {
 | 
						|
            BeginPCall();
 | 
						|
            PushGeneric(arg1);
 | 
						|
            PushGeneric(arg2);
 | 
						|
            PushGeneric(arg3);
 | 
						|
            PushGeneric(arg4);
 | 
						|
            PCall();
 | 
						|
            R1 ret1 = CheckValue<R1>();
 | 
						|
            EndPCall();
 | 
						|
            return ret1;
 | 
						|
        }
 | 
						|
 | 
						|
        public R1 Invoke<T1, T2, T3, T4, T5, R1>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5)
 | 
						|
        {
 | 
						|
            BeginPCall();
 | 
						|
            PushGeneric(arg1);
 | 
						|
            PushGeneric(arg2);
 | 
						|
            PushGeneric(arg3);
 | 
						|
            PushGeneric(arg4);
 | 
						|
            PushGeneric(arg5);
 | 
						|
            PCall();
 | 
						|
            R1 ret1 = CheckValue<R1>();
 | 
						|
            EndPCall();
 | 
						|
            return ret1;
 | 
						|
        }
 | 
						|
 | 
						|
        public R1 Invoke<T1, T2, T3, T4, T5, T6, R1>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6)
 | 
						|
        {
 | 
						|
            BeginPCall();
 | 
						|
            PushGeneric(arg1);
 | 
						|
            PushGeneric(arg2);
 | 
						|
            PushGeneric(arg3);
 | 
						|
            PushGeneric(arg4);
 | 
						|
            PushGeneric(arg5);
 | 
						|
            PushGeneric(arg6);
 | 
						|
            PCall();
 | 
						|
            R1 ret1 = CheckValue<R1>();
 | 
						|
            EndPCall();
 | 
						|
            return ret1;
 | 
						|
        }
 | 
						|
 | 
						|
        public R1 Invoke<T1, T2, T3, T4, T5, T6, T7, R1>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7)
 | 
						|
        {
 | 
						|
            BeginPCall();
 | 
						|
            PushGeneric(arg1);
 | 
						|
            PushGeneric(arg2);
 | 
						|
            PushGeneric(arg3);
 | 
						|
            PushGeneric(arg4);
 | 
						|
            PushGeneric(arg5);
 | 
						|
            PushGeneric(arg6);
 | 
						|
            PushGeneric(arg7);
 | 
						|
            PCall();
 | 
						|
            R1 ret1 = CheckValue<R1>();
 | 
						|
            EndPCall();
 | 
						|
            return ret1;
 | 
						|
        }
 | 
						|
 | 
						|
        public R1 Invoke<T1, T2, T3, T4, T5, T6, T7, T8, R1>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8)
 | 
						|
        {
 | 
						|
            BeginPCall();
 | 
						|
            PushGeneric(arg1);
 | 
						|
            PushGeneric(arg2);
 | 
						|
            PushGeneric(arg3);
 | 
						|
            PushGeneric(arg4);
 | 
						|
            PushGeneric(arg5);
 | 
						|
            PushGeneric(arg6);
 | 
						|
            PushGeneric(arg7);
 | 
						|
            PushGeneric(arg8);
 | 
						|
            PCall();
 | 
						|
            R1 ret1 = CheckValue<R1>();
 | 
						|
            EndPCall();
 | 
						|
            return ret1;
 | 
						|
        }
 | 
						|
 | 
						|
        public R1 Invoke<T1, T2, T3, T4, T5, T6, T7, T8, T9, R1>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9)
 | 
						|
        {
 | 
						|
            BeginPCall();
 | 
						|
            PushGeneric(arg1);
 | 
						|
            PushGeneric(arg2);
 | 
						|
            PushGeneric(arg3);
 | 
						|
            PushGeneric(arg4);
 | 
						|
            PushGeneric(arg5);
 | 
						|
            PushGeneric(arg6);
 | 
						|
            PushGeneric(arg7);
 | 
						|
            PushGeneric(arg8);
 | 
						|
            PushGeneric(arg9);            
 | 
						|
            PCall();
 | 
						|
            R1 ret1 = CheckValue<R1>();
 | 
						|
            EndPCall();
 | 
						|
            return ret1;
 | 
						|
        }
 | 
						|
 | 
						|
        //慎用, 有gc alloc
 | 
						|
        [System.Obsolete("LuaFunction.LazyCall() is obsolete.Use LuaFunction.Invoke()")]
 | 
						|
        public object[] LazyCall(params object[] args)
 | 
						|
        {
 | 
						|
            BeginPCall();
 | 
						|
            int count = args == null ? 0 : args.Length;
 | 
						|
 | 
						|
            if (!luaState.LuaCheckStack(count + 6))
 | 
						|
            {
 | 
						|
                EndPCall();
 | 
						|
                throw new LuaException("stack overflow");
 | 
						|
            }
 | 
						|
            
 | 
						|
            PushArgs(args);
 | 
						|
            PCall();
 | 
						|
            object[] objs = luaState.CheckObjects(oldTop);
 | 
						|
            EndPCall();
 | 
						|
            return objs;
 | 
						|
        }
 | 
						|
 | 
						|
        public void CheckStack(int args)
 | 
						|
        {
 | 
						|
            luaState.LuaCheckStack(args + 6);
 | 
						|
        }
 | 
						|
 | 
						|
        public bool IsBegin()
 | 
						|
        {
 | 
						|
            return oldTop != -1;
 | 
						|
        }
 | 
						|
 | 
						|
        public void Push(double num)
 | 
						|
        {
 | 
						|
            luaState.Push(num);
 | 
						|
            ++argCount;
 | 
						|
        }
 | 
						|
 | 
						|
        public void Push(int n)
 | 
						|
        {
 | 
						|
            luaState.Push(n);
 | 
						|
            ++argCount;
 | 
						|
        }
 | 
						|
 | 
						|
        public void PushLayerMask(LayerMask n)
 | 
						|
        {
 | 
						|
            luaState.PushLayerMask(n);
 | 
						|
            ++argCount;
 | 
						|
        }
 | 
						|
 | 
						|
        public void Push(uint un)
 | 
						|
        {
 | 
						|
            luaState.Push(un);
 | 
						|
            ++argCount;
 | 
						|
        }
 | 
						|
 | 
						|
        public void Push(long num)
 | 
						|
        {
 | 
						|
            luaState.Push(num);
 | 
						|
            ++argCount;
 | 
						|
        }
 | 
						|
 | 
						|
        public void Push(ulong un)
 | 
						|
        {
 | 
						|
            luaState.Push(un);
 | 
						|
            ++argCount;
 | 
						|
        }
 | 
						|
 | 
						|
        public void Push(bool b)
 | 
						|
        {
 | 
						|
            luaState.Push(b);
 | 
						|
            ++argCount;
 | 
						|
        }
 | 
						|
 | 
						|
        public void Push(string str)
 | 
						|
        {
 | 
						|
            luaState.Push(str);
 | 
						|
            ++argCount;
 | 
						|
        }
 | 
						|
 | 
						|
        public void Push(IntPtr ptr)
 | 
						|
        {
 | 
						|
            luaState.Push(ptr);
 | 
						|
            ++argCount;
 | 
						|
        }
 | 
						|
 | 
						|
        public void Push(LuaBaseRef lbr)
 | 
						|
        {
 | 
						|
            luaState.Push(lbr);
 | 
						|
            ++argCount;
 | 
						|
        }
 | 
						|
 | 
						|
        public void Push(object o)
 | 
						|
        {
 | 
						|
            luaState.PushVariant(o);
 | 
						|
            ++argCount;
 | 
						|
        }
 | 
						|
 | 
						|
        public void Push(UnityEngine.Object o)
 | 
						|
        {
 | 
						|
            luaState.Push(o);
 | 
						|
            ++argCount;
 | 
						|
        }
 | 
						|
 | 
						|
        public void Push(Type t)
 | 
						|
        {
 | 
						|
            luaState.Push(t);
 | 
						|
            ++argCount;
 | 
						|
        }
 | 
						|
 | 
						|
        public void Push(Enum e)
 | 
						|
        {
 | 
						|
            luaState.Push(e);
 | 
						|
            ++argCount;
 | 
						|
        }
 | 
						|
 | 
						|
        public void Push(Array array)
 | 
						|
        {
 | 
						|
            luaState.Push(array);
 | 
						|
            ++argCount;
 | 
						|
        }
 | 
						|
 | 
						|
        public void Push(Vector3 v3)
 | 
						|
        {
 | 
						|
            luaState.Push(v3);
 | 
						|
            ++argCount;
 | 
						|
        }
 | 
						|
 | 
						|
        public void Push(Vector2 v2)
 | 
						|
        {
 | 
						|
            luaState.Push(v2);
 | 
						|
            ++argCount;
 | 
						|
        }
 | 
						|
 | 
						|
        public void Push(Vector4 v4)
 | 
						|
        {
 | 
						|
            luaState.Push(v4);
 | 
						|
            ++argCount;
 | 
						|
        }
 | 
						|
 | 
						|
        public void Push(Quaternion quat)
 | 
						|
        {
 | 
						|
            luaState.Push(quat);
 | 
						|
            ++argCount;
 | 
						|
        }
 | 
						|
 | 
						|
        public void Push(Color clr)
 | 
						|
        {
 | 
						|
            luaState.Push(clr);
 | 
						|
            ++argCount;
 | 
						|
        }
 | 
						|
 | 
						|
        public void Push(Ray ray)
 | 
						|
        {
 | 
						|
            try
 | 
						|
            {
 | 
						|
                luaState.Push(ray);
 | 
						|
                ++argCount;
 | 
						|
            }
 | 
						|
            catch (Exception e)
 | 
						|
            {
 | 
						|
                EndPCall();
 | 
						|
                throw e;
 | 
						|
            }
 | 
						|
        }
 | 
						|
 | 
						|
        public void Push(Bounds bounds)
 | 
						|
        {
 | 
						|
            try
 | 
						|
            {
 | 
						|
                luaState.Push(bounds);
 | 
						|
                ++argCount;
 | 
						|
            }
 | 
						|
            catch (Exception e)
 | 
						|
            {
 | 
						|
                EndPCall();
 | 
						|
                throw e;
 | 
						|
            }
 | 
						|
        }
 | 
						|
 | 
						|
        public void Push(RaycastHit hit)
 | 
						|
        {
 | 
						|
            try
 | 
						|
            {
 | 
						|
                luaState.Push(hit);
 | 
						|
                ++argCount;
 | 
						|
            }
 | 
						|
            catch (Exception e)
 | 
						|
            {
 | 
						|
                EndPCall();
 | 
						|
                throw e;
 | 
						|
            }
 | 
						|
        }
 | 
						|
 | 
						|
        public void Push(Touch t)
 | 
						|
        {
 | 
						|
            try
 | 
						|
            {
 | 
						|
                luaState.Push(t);
 | 
						|
                ++argCount;
 | 
						|
            }
 | 
						|
            catch (Exception e)
 | 
						|
            {
 | 
						|
                EndPCall();
 | 
						|
                throw e;
 | 
						|
            }
 | 
						|
        }
 | 
						|
 | 
						|
        public void Push(LuaByteBuffer buffer)
 | 
						|
        {
 | 
						|
            try
 | 
						|
            {
 | 
						|
                luaState.Push(buffer);
 | 
						|
                ++argCount;
 | 
						|
            }
 | 
						|
            catch (Exception e)
 | 
						|
            {
 | 
						|
                EndPCall();
 | 
						|
                throw e;
 | 
						|
            }
 | 
						|
        }
 | 
						|
 | 
						|
        public void PushValue<T>(T value) where T : struct
 | 
						|
        {
 | 
						|
            try
 | 
						|
            {
 | 
						|
                luaState.PushValue(value);
 | 
						|
                ++argCount;
 | 
						|
            }
 | 
						|
            catch (Exception e)
 | 
						|
            {
 | 
						|
                EndPCall();
 | 
						|
                throw e;
 | 
						|
            }
 | 
						|
        }
 | 
						|
 | 
						|
        public void PushObject(object o)
 | 
						|
        {
 | 
						|
            try
 | 
						|
            {
 | 
						|
                luaState.PushObject(o);
 | 
						|
                ++argCount;
 | 
						|
            }
 | 
						|
            catch (Exception e)
 | 
						|
            {
 | 
						|
                EndPCall();
 | 
						|
                throw e;
 | 
						|
            }
 | 
						|
        }
 | 
						|
 | 
						|
        public void PushSealed<T>(T o)
 | 
						|
        {
 | 
						|
            try
 | 
						|
            {
 | 
						|
                luaState.PushSealed(o);
 | 
						|
                ++argCount;
 | 
						|
            }
 | 
						|
            catch (Exception e)
 | 
						|
            {
 | 
						|
                EndPCall();
 | 
						|
                throw e;
 | 
						|
            }
 | 
						|
        }
 | 
						|
 | 
						|
        public void PushGeneric<T>(T t)
 | 
						|
        {
 | 
						|
            try
 | 
						|
            {
 | 
						|
                luaState.PushGeneric(t);
 | 
						|
                ++argCount;
 | 
						|
            }
 | 
						|
            catch (Exception e)
 | 
						|
            {
 | 
						|
                EndPCall();
 | 
						|
                throw e;
 | 
						|
            }
 | 
						|
        }
 | 
						|
 | 
						|
        public void PushArgs(object[] args)
 | 
						|
        {
 | 
						|
            if (args == null)
 | 
						|
            {
 | 
						|
                return;
 | 
						|
            }
 | 
						|
 | 
						|
            argCount += args.Length;
 | 
						|
            luaState.PushArgs(args);
 | 
						|
        }
 | 
						|
 | 
						|
        public void PushByteBuffer(byte[] buffer, int len = -1)
 | 
						|
        {
 | 
						|
            try
 | 
						|
            {
 | 
						|
                if (len == -1)
 | 
						|
                {
 | 
						|
                    len = buffer.Length;
 | 
						|
                }
 | 
						|
 | 
						|
                luaState.PushByteBuffer(buffer, len);
 | 
						|
                ++argCount;
 | 
						|
            }
 | 
						|
            catch (Exception e)
 | 
						|
            {
 | 
						|
                EndPCall();
 | 
						|
                throw e;
 | 
						|
            }
 | 
						|
        }
 | 
						|
 | 
						|
        public double CheckNumber()
 | 
						|
        {
 | 
						|
            try
 | 
						|
            {
 | 
						|
                return luaState.LuaCheckNumber(stackPos++);
 | 
						|
            }
 | 
						|
            catch (Exception e)
 | 
						|
            {
 | 
						|
                EndPCall();
 | 
						|
                throw e;
 | 
						|
            }
 | 
						|
        }
 | 
						|
 | 
						|
        public bool CheckBoolean()
 | 
						|
        {
 | 
						|
            try
 | 
						|
            {
 | 
						|
                return luaState.LuaCheckBoolean(stackPos++);
 | 
						|
            }
 | 
						|
            catch (Exception e)
 | 
						|
            {
 | 
						|
                EndPCall();
 | 
						|
                throw e;
 | 
						|
            }
 | 
						|
        }
 | 
						|
 | 
						|
        public string CheckString()
 | 
						|
        {
 | 
						|
            try
 | 
						|
            {
 | 
						|
                return luaState.CheckString(stackPos++);
 | 
						|
            }
 | 
						|
            catch (Exception e)
 | 
						|
            {
 | 
						|
                EndPCall();
 | 
						|
                throw e;
 | 
						|
            }
 | 
						|
        }
 | 
						|
 | 
						|
        public Vector3 CheckVector3()
 | 
						|
        {
 | 
						|
            try
 | 
						|
            {
 | 
						|
                return luaState.CheckVector3(stackPos++);
 | 
						|
            }
 | 
						|
            catch (Exception e)
 | 
						|
            {
 | 
						|
                EndPCall();
 | 
						|
                throw e;
 | 
						|
            }
 | 
						|
        }
 | 
						|
 | 
						|
        public Quaternion CheckQuaternion()
 | 
						|
        {
 | 
						|
            try
 | 
						|
            {
 | 
						|
                return luaState.CheckQuaternion(stackPos++);
 | 
						|
            }
 | 
						|
            catch (Exception e)
 | 
						|
            {
 | 
						|
                EndPCall();
 | 
						|
                throw e;
 | 
						|
            }
 | 
						|
        }
 | 
						|
 | 
						|
        public Vector2 CheckVector2()
 | 
						|
        {
 | 
						|
            try
 | 
						|
            {
 | 
						|
                return luaState.CheckVector2(stackPos++);
 | 
						|
            }
 | 
						|
            catch (Exception e)
 | 
						|
            {
 | 
						|
                EndPCall();
 | 
						|
                throw e;
 | 
						|
            }
 | 
						|
        }
 | 
						|
 | 
						|
        public Vector4 CheckVector4()
 | 
						|
        {
 | 
						|
            try
 | 
						|
            {
 | 
						|
                return luaState.CheckVector4(stackPos++);
 | 
						|
            }
 | 
						|
            catch (Exception e)
 | 
						|
            {
 | 
						|
                EndPCall();
 | 
						|
                throw e;
 | 
						|
            }
 | 
						|
        }
 | 
						|
 | 
						|
        public Color CheckColor()
 | 
						|
        {
 | 
						|
            try
 | 
						|
            {
 | 
						|
                return luaState.CheckColor(stackPos++);
 | 
						|
            }
 | 
						|
            catch (Exception e)
 | 
						|
            {
 | 
						|
                EndPCall();
 | 
						|
                throw e;
 | 
						|
            }
 | 
						|
        }
 | 
						|
 | 
						|
        public Ray CheckRay()
 | 
						|
        {
 | 
						|
            try
 | 
						|
            {
 | 
						|
                return luaState.CheckRay(stackPos++);
 | 
						|
            }
 | 
						|
            catch (Exception e)
 | 
						|
            {
 | 
						|
                EndPCall();
 | 
						|
                throw e;
 | 
						|
            }
 | 
						|
        }
 | 
						|
 | 
						|
        public Bounds CheckBounds()
 | 
						|
        {
 | 
						|
            try
 | 
						|
            {
 | 
						|
                return luaState.CheckBounds(stackPos++);
 | 
						|
            }
 | 
						|
            catch (Exception e)
 | 
						|
            {
 | 
						|
                EndPCall();
 | 
						|
                throw e;
 | 
						|
            }
 | 
						|
        }
 | 
						|
 | 
						|
        public LayerMask CheckLayerMask()
 | 
						|
        {
 | 
						|
            try
 | 
						|
            {
 | 
						|
                return luaState.CheckLayerMask(stackPos++);
 | 
						|
            }
 | 
						|
            catch (Exception e)
 | 
						|
            {
 | 
						|
                EndPCall();
 | 
						|
                throw e;
 | 
						|
            }
 | 
						|
        }
 | 
						|
 | 
						|
        public long CheckLong()
 | 
						|
        {
 | 
						|
            try
 | 
						|
            {
 | 
						|
                return luaState.CheckLong(stackPos++);
 | 
						|
            }
 | 
						|
            catch (Exception e)
 | 
						|
            {
 | 
						|
                EndPCall();
 | 
						|
                throw e;
 | 
						|
            }
 | 
						|
        }
 | 
						|
 | 
						|
        public ulong CheckULong()
 | 
						|
        {
 | 
						|
            try
 | 
						|
            {
 | 
						|
                return luaState.CheckULong(stackPos++);
 | 
						|
            }
 | 
						|
            catch (Exception e)
 | 
						|
            {
 | 
						|
                EndPCall();
 | 
						|
                throw e;
 | 
						|
            }
 | 
						|
        }
 | 
						|
 | 
						|
        public Delegate CheckDelegate()
 | 
						|
        {
 | 
						|
            try
 | 
						|
            {
 | 
						|
                return luaState.CheckDelegate(stackPos++);
 | 
						|
            }
 | 
						|
            catch (Exception e)
 | 
						|
            {
 | 
						|
                EndPCall();
 | 
						|
                throw e;
 | 
						|
            }
 | 
						|
        }
 | 
						|
 | 
						|
        public object CheckVariant()
 | 
						|
        {
 | 
						|
            return luaState.ToVariant(stackPos++);
 | 
						|
        }
 | 
						|
 | 
						|
        public char[] CheckCharBuffer()
 | 
						|
        {
 | 
						|
            try
 | 
						|
            {
 | 
						|
                return luaState.CheckCharBuffer(stackPos++);
 | 
						|
            }
 | 
						|
            catch (Exception e)
 | 
						|
            {
 | 
						|
                EndPCall();
 | 
						|
                throw e;
 | 
						|
            }
 | 
						|
        }
 | 
						|
 | 
						|
        public byte[] CheckByteBuffer()
 | 
						|
        {
 | 
						|
            try
 | 
						|
            {
 | 
						|
                return luaState.CheckByteBuffer(stackPos++);
 | 
						|
            }
 | 
						|
            catch (Exception e)
 | 
						|
            {
 | 
						|
                EndPCall();
 | 
						|
                throw e;
 | 
						|
            }
 | 
						|
        }
 | 
						|
 | 
						|
        public object CheckObject(Type t)
 | 
						|
        {
 | 
						|
            try
 | 
						|
            {
 | 
						|
                return luaState.CheckObject(stackPos++, t);
 | 
						|
            }
 | 
						|
            catch (Exception e)
 | 
						|
            {
 | 
						|
                EndPCall();
 | 
						|
                throw e;
 | 
						|
            }
 | 
						|
        }
 | 
						|
 | 
						|
        public LuaFunction CheckLuaFunction()
 | 
						|
        {
 | 
						|
            try
 | 
						|
            {
 | 
						|
                return luaState.CheckLuaFunction(stackPos++);
 | 
						|
            }
 | 
						|
            catch (Exception e)
 | 
						|
            {
 | 
						|
                EndPCall();
 | 
						|
                throw e;
 | 
						|
            }
 | 
						|
        }
 | 
						|
 | 
						|
        public LuaTable CheckLuaTable()
 | 
						|
        {
 | 
						|
            try
 | 
						|
            {
 | 
						|
                return luaState.CheckLuaTable(stackPos++);
 | 
						|
            }
 | 
						|
            catch (Exception e)
 | 
						|
            {
 | 
						|
                EndPCall();
 | 
						|
                throw e;
 | 
						|
            }
 | 
						|
        }
 | 
						|
 | 
						|
        public LuaThread CheckLuaThread()
 | 
						|
        {
 | 
						|
            try
 | 
						|
            {
 | 
						|
                return luaState.CheckLuaThread(stackPos++);
 | 
						|
            }
 | 
						|
            catch (Exception e)
 | 
						|
            {
 | 
						|
                EndPCall();
 | 
						|
                throw e;
 | 
						|
            }
 | 
						|
        }
 | 
						|
 | 
						|
        public T CheckValue<T>()
 | 
						|
        {
 | 
						|
            try
 | 
						|
            {
 | 
						|
                return luaState.CheckValue<T>(stackPos++);
 | 
						|
            }
 | 
						|
            catch (Exception e)
 | 
						|
            {
 | 
						|
                EndPCall();
 | 
						|
                throw e;
 | 
						|
            }
 | 
						|
        }
 | 
						|
    }    
 | 
						|
}
 |